QuantConnect Documentation - Writing Algorithms

Created on 05/17/2023

Table of Content

Introduction

Quantitative trading is a method of trading where computer programs execute a set of defined trading rules in an automated fashion. Quants take a scientific approach to trading, applying concepts from mathematics, time series analysis, statistics, computer science, and machine learning. Compared to discretionary traders, quants can respond faster to new information and are at less risk to their emotions during trades. Since quants can concurrently trade many strategies while discretionary traders only have the mental bandwidth to trade a small number of concurrent strategies, quant traders can have more diversified portfolios.

Learn Programming

We aim to make it as easy as possible to use QuantConnect, but you still need to be able to program. The following table provides some resources to get you started:

Enroll in Bootcamp

Bootcamp is an online coding experience where QuantConnect team and community members teach you to write your first algorithms. Bootcamp gives you step-by-step instructions on practical and beginner-friendly topics, so it's a great way to learn LEAN. The lessons cover many topics that you use as you write your own algorithms, including universe selection , indicators , and consolidators . To get started, check out the course library .

Example Algorithm

The following video demonstrates how to implement an algorithm that buys and holds an S&P 500 index ETF:

// Import all the functionality you need to run algorithms
using QuantConnect.Data;

// Define a trading algorithm that is a subclass of QCAlgorithm
namespace QuantConnect.Algorithm.CSharp
{
    public class MyAlgorithm : QCAlgorithm
    {
        // Define an Initialize method.
        // This method is the entry point of your algorithm where you define a series of settings.
        // LEAN only calls this method one time, at the start of your algorithm.
        public override void Initialize()
        {
            // Set the start and end dates
            SetStartDate(2018, 1, 1);
            SetEndDate(2022, 6, 1);
            // Set the starting cash balance to $100,000 USD
            SetCash(100000);
            // Add data for the S&P500 index ETF
            AddEquity("SPY");
        }

        // Define an OnData method. 
        // This method receives all the data you subscribe to in discrete time slices.
        // It's where you make trading decisions.
        public override void OnData(Slice slice)
        {
            // Allocate 100% of the portfolio to SPY
            if (!Portfolio.Invested)
            {
                SetHoldings("SPY", 1);
            }
        }
    }
}

# Import all the functionality you need to run algorithms
from AlgorithmImports import *

# Define a trading algorithm that is a subclass of QCAlgorithm
class MyAlgorithm(QCAlgorithm):
    # Define an Initialize method.
    # This method is the entry point of your algorithm where you define a series of settings.
    # LEAN only calls this method one time, at the start of your algorithm.
    def Initialize(self) -> None:
        # Set start and end dates
        self.SetStartDate(2018, 1, 1)
        self.SetEndDate(2022, 6, 1)
        # Set the starting cash balance to $100,000 USD
        self.SetCash(100000)
        # Add data for the S&P500 index ETF
        self.AddEquity("SPY")

    # Define an OnData method. 
    # This method receives all the data you subscribe to in discrete time slices.
    # It's where you make trading decisions.
    def OnData(self, slice: Slice) -> None:
        # Allocate 100% of the portfolio to SPY
        if not self.Portfolio.Invested:
            self.SetHoldings("SPY", 1)

Introduction

LEAN Engine is an open-source algorithmic trading engine built for easy strategy research, backtesting, and live trading. We integrate with common data providers and brokerages, so you can quickly deploy algorithmic trading strategies. The core of the LEAN Engine is written in C#, but it operates seamlessly on Linux, Mac and Windows operating systems. To use it, you can write algorithms in Python 3.8 or C#. QuantConnect maintains the LEAN project and uses it to drive the web-based algorithmic trading platform on the website.

Since LEAN is open-source, you aren't locked-in to the QuantConnect platform. You can run LEAN with your own infrastructure, data, and brokerage connections. If you use QuantConnect, our team of engineers manage the infrastructure, you can run the latest version of LEAN with all of its brokerage connections, and you can utilize the datasets in the Dataset Market .

Your Algorithm and LEAN

To create a trading algorithm with LEAN, define a subclass of the QCAlgorithm class. LEAN loads your algorithm into the engine during the building and compilation process. LEAN runs an algorithm manager that synchronizes the data your algorithm requests, injects the data into your algorithm so you can place trades, processes your orders, and then updates your algorithm state.

The LEAN engine manages your portfolio and data feeds, so you focus on your algorithm strategy and execution. We automatically provide basic portfolio management and reality modeling underneath the hood. The QCAlgorithm class provides some key helper properties for you to use, including the Security Manager, Portfolio Manager, Transactions Manager, Notification Manager, and Scheduling Manager. The class also has hundreds of helper methods to make the API easy to use.

The Securities property is a dictionary of Security objects. Each asset (Equity, Forex pair, etc) in your algorithm has a Security object. All the models for a security live on these objects. For example, Securities["IBM"].FeeModel and Securities["IBM"].Price self.Securities["IBM"].FeeModel and self.Securities["IBM"].Price return the fee model and price of IBM, respectively.

The Portfolio is a dictionary of SecurityHolding objects. These classes track the profits, losses, fees, and quantity of individual portfolio holdings. For example, Portfolio["IBM"].LastTradeProfit self.Portfolio["IBM"].LastTradeProfit returns the profit of your last IBM trade.

Other helpers like Transactions , Schedule , Notify , and Universe have their own helper methods.

public class QCAlgorithm
{
    SecurityManager Securities;               // Array of Security objects.
    SecurityPortfolioManager Portfolio;       // Array of SecurityHolding objects
    SecurityTransactionManager Transactions;  // Transactions helper
    ScheduleManager Schedule;                 // Scheduling helper
    NotificationManager Notify;               // Email, SMS helper
    UniverseManager Universe;                 // Universe helper

    // Set up Requested Data, Cash, Time Period.
    public virtual void Initialize() { ... };

    // Event Handlers:
    public virtual void OnData(Slice slice) { ... };
    public virtual void OnEndOfDay(Symbol symbol) { ... };
    public virtual void OnEndOfAlgorithm() { ... };

    // Indicator Helpers
    public SimpleMovingAverage SMA(Symbol symbol, int period) { ... };
}

class QCAlgorithm:
    Securities   # Array of Security objects.
    Portfolio    # Array of SecurityHolding objects
    Transactions # Transactions helper
    Schedule     # Scheduling helper
    Notify       # Email, SMS helper
    Universe     # Universe helper

    # Set up Requested Data, Cash, Time Period.
    def Initialize(self) -> None:

    # Other Event Handlers
    def OnData(self, slice: Slice) -> None:
    def OnEndOfDay(self, symbol: Symbol) -> None:
    def OnEndOfAlgorithm(self) -> None:

    # Indicator Helpers
    def SMA(self, symbol: Symbol, period: int) -> SimpleMovingAverage:

Threads in LEAN

LEAN is multi-threaded and attempts to consume as much CPU as possible to perform given work as quickly as possible. The analysis engine loads data parallel and synchronizes it to generate the requested security information.

The client algorithm is plugged into LEAN, and has its events triggered synchronously in backtesting. The primary bottle neck to LEAN execution is executing client code.

In live trading, most events are synchronous as in backtesting, however order events are triggered immediately from the brokerage thread (asynchronously) to ensure the lowest latency. For example; a strategy using hourly data, with a limit order could fill between data bars. This fill event is triggered when it occurs in live trading.

We recommend using thread safe collections when possible, or locks around collections to ensure they are thread-safe.

Batch vs Stream Analysis

Backtesting platforms come in two general varieties, batch processing and event streaming. Batch processing backtesting is much simpler. It loads all data into an array and passes it to your algorithm for analysis. Because your algorithm has access to future data points, it is easy to introduce look-ahead bias . Most home-grown analysis tools are batch systems.

QuantConnect/LEAN is a streaming analysis system. In live trading, your algorithm receives data points one after another over time. QuantConnect models this in backtesting, streaming data to your algorithm in fast-forward mode. Because of this, you can't access price data beyond the Time Frontier . Although streaming analysis is slightly trickier to understand, it allows your algorithm to seamlessly work in backtests and live trading with no code changes.

Event Flow

When you deploy an algorithm, LEAN first calls the Initialize method. In live mode, the engine loads your holdings and open orders from your brokerage account to add data subscriptions and populate the Securities , Portfolio , and Transactions objects. LEAN receives the data from the subscriptions, synchronizes the data to create a timeslice , and then performs the following steps. Your algorithm can spend up to 10 minutes on each timeslice unless you call the Train method.

1. If it's a backtest, check if there are Scheduled Events in the past that didn't fire because there was no data between the previous slice and the current slice. LEAN automatically creates a Scheduled Event to call the OnEndOfDay method at the end of each day.

In live mode, Scheduled Events occur in a separate thread from the algorithm manager, so they run at the correct time.

2. Update the algorithm time.
3. Update the CurrentSlice .
4. Cancel all open orders for securities that changed their ticker .
5. Add a Security object to the Securities collection for each new security in the universe.
6. Update the Security objects with the latest data.
7. Update the Cash objects in the CashBook with the latest data.
8. Process fill models for non-market orders.
   
9. Submit market on open orders to liquidate Equity Option contracts if the underlying Equity has a split warning .
10. Process margin calls .
    
11. If it's time to settle unsettled cash , perform settlement.
12. Call the OnSecuritiesChanged method with the latest security changes.
13. Apply dividends to the portfolio.
14. For securities that have a split warning, update their portfolio holdings and adjust their open orders to account for the split.
15. Update consolidators with the latest data.
    
16. Pass custom data to the OnData method.
17. Pass Dividends to the OnData method.
18. Pass Splits to the OnData method.
19. Pass Delistings to the OnData method.
20. Pass TradeBars to the OnData method.
21. Pass QuoteBars to the OnData method.
22. Pass OptionChains to the OnData method.
23. Pass Ticks to the OnData method.
24. Pass the Slice to the OnData method.
25. Perform universe selection .
26. Pass the Slice to the Update method of each Alpha model .
27. Pass the Insight objects from the Alpha model to the Portfolio Construction model .
28. Pass the PortfolioTarget objects from the Portfolio Construction model to each Risk Management model .
29. Pass the risk-adjusted PortfolioTarget objects from the Risk Management models to the Execution model .

When your algorithm stops executing, LEAN calls the OnEndOfAlgorithm method .

Python Support

The LEAN engine is written in C#, but you can create algorithms in C# or Python. If you program in Python, LEAN uses Python.Net to bridge between the C# engine and your algorithm. As a result of the bridge, QCAlgorithm class members are in camel case, not snake case. It can be slow to move from Python to C#. If you access C# objects in your Python algorithm, it's fastest to only access them once and save a reference if you need to access them again.

# Do this:
security_holding = self.Portfolio[self.symbol]
avg_price = security_holding.AveragePrice
quantity = security_holding.Quantity

# Avoid this:
avg_price = self.Portfolio[self.symbol].AveragePrice
quantity = self.Portfolio[self.symbol].Quantity

Introduction

We designed LEAN as a multi-asset platform with out-of-the-box support for multiple securities, so you can model complex portfolios like hedge funds.

Asset Portfolio

The portfolio manages the individual securities it contains. It tracks the cost of holding each security. It aggregates the performance of the individual securities in the portfolio to produce statistics like net profit and drawdown . The portfolio also holds information about each currency in its cashbook.

Cashbooks

We designed LEAN to be a multi-currency platform. LEAN can trade Forex, Cryptocurrencies, and other assets that are quoted in other currencies. A benefit of supporting multiple currencies is that as we add new asset classes from new countries, LEAN is already prepared to transact in those assets by using their quote currency. For instance, we added the India Equity market, which quotes assets in the INR currency.

The portfolio manages your currencies in its cashbook, which models the cash as a ledger of transactions. When you buy assets, LEAN uses the currencies in your cashbook to purchase the asset and pay the transaction fees. For more information about the cashbook, see Cashbook .

Buying Power

We model the margin requirements of each asset and reflect that in the buying power available to the algorithm. We source Futures margins from CME SPAN margins. Equity margin is 2x for standard margin accounts and 4x intraday for Pattern Day Trading accounts. For more information about buying power modeling, see Buying Power .

Introduction

Data comes in two different "shapes" according to the time period it covers: point values or period values. In QuantConnect, ticks are point values, and bars are a period values. These data formats have different properties, which control when LEAN emits them into your algorithm.

Start and End Time

Bars have a start and end time that represent the time period of which the bar aggregates data. LEAN passes the bar to your algorithm at the end time so that you don't receive the bar before it was actually available. Other data providers commonly timestamp their bars to the start time of the bar. This can cause one-off errors when you import the data into QC or compare indicator values across different platforms.

Period Values

Bars aggregate data across a period of time into a single object. We make this easy for you by pre-aggregating billions of raw trade-ticks into TradeBar objects and quote-ticks into QuoteBar objects.

We don't know the close of a bar until the start of the next bar, which can sometimes be confusing. For example, a price bar for Friday will include all the ticks from Friday 00:00:00 to Friday 23:59:59.99999, but LEAN will emit it to your algorithm on Saturday at midnight. As a result, if you analyze the Friday data and then place an order, LEAN sends the order to your brokerage on Saturday.

When there are no ticks during a period, LEAN emits the previous bar. This is the default behavior for bar data and it's referred to as "filling the data forward". You can enable and disable this setting when you create the security subscription .

We provide bar data in second, minute, hour, and daily bar formats. To create other periods of bars, see Consolidating Data .

Daily Periods

LEAN emits daily bars at midnight. To be notified when a security has finished trading for the day, add an OnEndOfDay method to your algorithm. LEAN calls this method for each security every day.

def OnEndOfDay(self, symbol: Symbol) -> None:
    pass

public override void OnEndOfDay(Symbol symbol)
{
    
}

Point Values

Point values have no period because they occur at a singular point in time. Examples of point data includes ticks, open interest, and news releases. Tick data represents a single trade or quote in the market. It's a discrete event with no period, so the Time and EndTime properties are the same. LEAN emits ticks as soon as they arrive and doesn't fill them forward.

Introduction

The core technology behind QuantConnect algorithmic trading is an event-based, streaming analysis system called LEAN . LEAN attempts to model the stream of time as accurately as possible, presenting data ("events") to your algorithms in the order it arrives, as you would experience in reality.

All QuantConnect algorithms have this time-stream baked in as the primary event handler, OnData . The Slice object this method receives represents all of the data at a moment of time, a time-slice . No matter what data you request, you receive it in the order created according to simulated algorithm time. By only letting your algorithm see the present and past moments, we can prevent the most common quantitative-analysis error, look-ahead bias .

Time Frontier

If you request data for multiple securities and multiple resolutions, it can create a situation where one of your data subscriptions is ready to emit, but another subscription with a longer period is still be constructing its bar. Furthermore, if you request multiple datasets that have different time zones, your algorithm will receive the daily bars of each dataset at midnight in the respective time zone. To coordinate the data in these situations, we use the EndTime of each data point to signal when LEAN should transmit it to your algorithm.

Once your algorithm reaches the EndTime of a data point, LEAN sends the data to your OnData method. For bar data, this is the beginning of the next period. To avoid look-ahead bias, you can only access data from before this Time Frontier. The Time property of your algorithm is always equal to the Time Frontier.

Properties

Slice objects have the following properties:

Get Time Slices

To get the current Slice object, define an OnData method or use the CurrentSlice property of your algorithm. The Slice contains all the data for a given moment in time. The TradeBars and QuoteBars properties are Symbol /string indexed dictionaries. The Ticks property is a list of ticks for that moment of time, indexed by the Symbol . To check which data formats are available for each asset class, see the Data Formats page in the Asset Classes chapter.

The Slice object gives you the following ways to access your data:

• Indexing the Slice , which returns a dynamic object of your type.

def OnData(self, slice: Slice) -> None:
    data = slice[self.symbol]

public override void OnData(Slice slice)
{
    var data = slice[_symbol];
}

With minute and second resolution data, the dynamic type is TradeBar for Equities and QuoteBar for other asset classes.

• Indexing the static properties, which returns the type you specify.

def OnData(self, slice: Slice) -> None:
    trade_bar = slice.Bars[self.symbol]
    quote_bar = slice.QuoteBars[self.symbol]

public override void OnData(Slice slice)
{
    var tradeBars = slice.Bars[_symbol];
    var quoteBars = slice.QuoteBars[_symbol];
}

• Calling the Get<T>() helper method.

public override void OnData(Slice slice)
{
    var tradeBar = slice.Get<TradeBar>(_symbol);
    var quoteBar = slice.Get<QuoteBar>(_symbol);
    var ticks = slice.Get<Ticks>(_symbol);
}

Strongly typed access gives you compile-time safety, but dynamic type access can sometimes simplify coding. We recommend static types since they are easier to debug.

Check if the Slice contains the data you're looking for before you index it. If there is little trading, or you are in the same time loop as when you added the security, it may not have any data. Even if you enabled fill-forward for a security subscription, you should check if the data exists in the dictionary before you try to index it. To check if the Slice contains for a security, call the ContainsKey method. Note: if the Slice object doesn't contain any market data but it contains auxiliary data, the slice.ContainsKey(symbol) method can return true while slice[symbol] returns None null .

def OnData(self, slice: Slice) -> None:
    if slice.ContainsKey(self.symbol) and slice[self.symbol] is not None:
        data = slice[self.symbol]

public override void OnData(Slice slice)
{
    if (slice.ContainsKey(_symbol))
    {
        var data = slice[_symbol];
    }
}

Introduction

LEAN is an international trading engine, so it can operate across time zones. The exchange, your algorithm, and the data in your algorithm can all have different time zones.

Exchange Time Zone

Exchanges are located in different areas, so they can have different time zones. To get the time zone of the exchange that a Security trades on, use its Exchange.Hours.TimeZone property.

var timeZone = Securities[_symbol].Exchange.Hours.TimeZone;

time_zone = self.Securities[self.symbol].Exchange.Hours.TimeZone

Algorithm Time Zone

LEAN supports international trading across multiple time zones and markets, so it needs a reference time zone for the algorithm to set the Time . The default time zone is Eastern Time (ET), which is UTC-4 in summer and UTC-5 in winter. To set a different time zone, call the SetTimeZone method. This method accepts either a string following the IANA Time Zone database convention or a NodaTime .DateTimeZone object. If you pass a string, the method converts it to a NodaTime.DateTimeZone object. The TimeZones class provides the following helper attributes to create NodaTime.DateTimeZone objects:

SetTimeZone("Europe/London");
SetTimeZone(NodaTime.DateTimeZone.Utc);
SetTimeZone(TimeZones.Chicago);

self.SetTimeZone("Europe/London")
self.SetTimeZone(TimeZones.Chicago)

To get the time zone of your algorithm, use the TimeZone property.

time_zone = self.TimeZone

var timeZone = TimeZone;

To get the algorithm time in Coordinated Universal Time (UTC), use the UtcTime property.

utc_time = self.UtcTime

var utcTime = UtcTime;

The Time and UtcTime objects have no time zone. LEAN maintains their state to be consistent.

Data Time Zone

Datasets can have different time zones because the time zone is up to the data provider, where they are located, and where they collect the data. LEAN tracks the time zone of each dataset so that you receive the correct data at the right point in time in your algorithm. If you have multiple datasets in your algorithm from different time zones, LEAN synchronizes them to your algorithm time. Furthermore, if you set up time period consolidators , LEAN consolidates the data based on the data time zone.

To get the time zone of a dataset, view the listing page in the Dataset Market or call the GetDataTimeZone method.

time_zone = self.MarketHoursDatabase.GetDataTimeZone(Market.USA, self.symbol, SecurityType.Equity)

var timeZone = MarketHoursDatabase.GetDataTimeZone(Market.USA, _symbol, SecurityType.Equity);

Introduction

We implemented Symbol objects in the LEAN open-source project as a way to identify or "finger-print" tradable assets so that no further database look-up is required. All QuantConnect and LEAN Algorithm API methods use Symbol objects to identify assets.

Encoding Symbols

SecurityIdentifier objects have several public properties to uniquely identify each asset. The following table describes these properties:

We encode the preceding properties to create Symbol objects. We do our best to hide the details of this process from your algorithm, but you'll occasionally see it come through as an encoded hash like AAPL R735QTJ8XC9X . The first half of the encoded string represents the first ticker AAPL was listed under. The other letters at the end of the string represent the serialized form of the preceding SecurityIdentifier properties. You may also see an encoded has like AAPL XL7X5I241SO6|AAPL R735QTJ8XC9X for a derivative contract. In this case, the part before the | is contract hash and the part after the | is the underlying hash. This serialization approach lets LEAN assign a short, unique string to octillions of different security objects.

The following table shows the results of our encoding process given the preceding SecurityIdentifier properties:

LEAN assumes the ticker you pass to the AddEquity method is the current ticker of the Equity asset. To access this ticker, use the Value property of the Symbol object.

self.symbol = self.AddEquity("GOOG").Symbol
self.Debug(self.symbol.ID.Value) # Prints "GOOCV"
self.Debug(self.symbol.Value)    # Prints "GOOG"

var symbol = AddEquity("GOOG").Symbol;
Debug(symbol.ID.Value); // Prints "GOOCV"
Debug(symbol.Value);    // Prints "GOOG"

If you create the security subscription with a universe selection function, the Value property of the Symbol object is the point-in-time ticker.

Decoding Symbols

When a SecurityIdentifier is serialized to a string, it looks something like SPY R735QTJ8XC9X . This two-part string is a base64 encoded set of data. Encoding all of the properties into a short format allows dense communication without requiring a third-party list or look-up. Most of the time, you will not need to work with these encoded strings. However, to deserialize the string into a Symbol object, call the Symbol method.

var symbol = Symbol("GOOCV VP83T1ZUHROL");
symbol.ID.Market;     // => "USA"
symbol.SecurityType;  // => SecurityType.Equity
symbol.Value;         // => "GOOCV"

symbol = self.Symbol("GOOCV VP83T1ZUHROL")
symbol.ID.Market     # => "USA"
symbol.SecurityType  # => SecurityType.Equity
symbol.Value         # => "GOOCV"

The Market property distinguishes between tickers that have the same string value but represent different underlying assets. A prime example of this is the various market makers who have different prices for EURUSD. We store this data separately and as they have different fill prices, we treat the execution venues as different markets.

Tickers

Tickers are a string shortcode representation for an asset. Some examples of popular tickers include "AAPL" for Apple Corporation and "IBM" for International Business Machines Corporation. These tickers often change when the company rebrands or they undergo a merger or reverse merger.

The ticker of an asset is not the same as the Symbol . Symbol objects are permanent and track the underlying entity. When a company rebrands or changes its name, the Symbol object remains constant, giving algorithms a way to reliably track assets over time.

Tickers are also often reused by different brokerages. For example Coinbase, a leading US Crypto Brokerage lists the "BTCUSD" ticker for trading. Its competitor, Bitfinex, also lists "BTCUSD". You can trade both tickers with LEAN. Symbol objects allow LEAN to identify which market you reference in your algorithms.

To create a Symbol object for a point-in-time ticker, call the GenerateEquity method to create the security identifier and then call the Symbol constructor. For example, Heliogen, Inc. changed their ticker from ATHN to HLGN on December 31, 2021. To convert the ATHN ticker to the Equity Symbol , type:

ticker = "ATHN"
security_id = SecurityIdentifier.GenerateEquity(ticker, Market.USA, mappingResolveDate=datetime(2021, 12, 1))
symbol = Symbol(security_id, ticker)

var ticker = "ATHN";
var securityID = SecurityIdentifier.GenerateEquity(ticker, Market.USA, mappingResolveDate:new DateTime(2021, 12, 1));
var symbol = new Symbol(securityID, ticker);

In the preceding code snippet, the mappingResolveDate must be a date when the point-in-time ticker was trading.

Symbol Cache

To make using the API easier, we have built the Symbol Cache technology, which accepts strings and tries to guess which Symbol object you might mean. With the Symbol Cache, many methods can accept a string such as "IBM" instead of a complete Symbol object. We highly recommend you don't rely on this technology and instead save explicit references to your securities when you need them.

# Example 1: Relying On Symbol Cache:
self.AddEquity("IBM")         # Add by IBM string ticker, save reference to Symbol Cache.
self.MarketOrder("IBM", 100)  # Determine refering to IBM Equity from Symbol Cache.
self.History("AAPL", 14)      # Makes a guess referring to AAPL Equity.

# Example 2: Correctly Using Symbols: 
self.ibm = self.AddEquity("IBM").Symbol   # Add IBM Equity string ticker, save Symbol.
self.MarketOrder(self.ibm, 100)           # Use IBM Symbol in future API calls.

self.aapl = Symbol.Create("AAPL", SecurityType.Equity, Market.USA)
self.History(self.aapl, 14)

// Example 1: Relying On Symbol Cache:
AddEquity("IBM");         // Add by IBM string ticker, save reference to Symbol Cache.
MarketOrder("IBM", 100);  // Determine refering to IBM Equity from Symbol Cache.
History("AAPL", 14);      // Guess referring to AAPL Equity.

// Example 2: Correctly Using Symbols: 
var ibm = AddEquity("IBM").Symbol;   // Add IBM Equity string ticker, save Symbol.
MarketOrder(ibm, 100);               // Use IBM Symbol in future API calls.

var aapl = Symbol.Create("AAPL", SecurityType.Equity, Market.USA);
History(aapl, 14);

Industry Standard Identifiers

You can convert industry-standard security identifiers like CUSIP, FIGI, ISIN, and SEDOL to Symbol objects and you can convert Symbol objects to industry-standard security identifiers.

CUSIP

To convert a Committee on Uniform Securities Identification Procedures (CUSIP) number to a Symbol or a Symbol to a CUSIP number, call the CUSIP method.

symbol = self.CUSIP("03783310") # AAPL Symbol
cusip = self.CUSIP(symbol) # AAPL CUSIP (03783310)

var symbol = CUSIP("03783310"); // AAPL Symbol
var cusip = CUSIP(symbol); // AAPL CUSIP (03783310)

FIGI

To convert a Financial Instrument Global Identifier (FIGI) to a Symbol or a Symbol to a FIGI, call the CompositeFIGI method.

symbol = self.CompositeFIGI("BBG000B9XRY4") # AAPL Symbol
figi = self.CompositeFIGI(symbol) # AAPL FIGI (BBG000B9XRY4)

var symbol = CompositeFIGI("BBG000B9XRY4"); // AAPL Symbol
var figi = CompositeFIGI(symbol); // AAPL FIGI (BBG000B9XRY4)

ISIN

To convert an International Securities Identification Number (ISIN) to a Symbol or a Symbol to an ISIN, call the ISIN method.

symbol = self.ISIN("US0378331005") # AAPL Symbol
isin = self.ISIN(symbol) # AAPL ISIN (US0378331005)

var symbol = ISIN("US0378331005"); // AAPL Symbol
var isin = ISIN(symbol); // AAPL ISIN (US0378331005)

SEDOL

To convert a Stock Exchange Daily Official List (SEDOL) number to a Symbol or a Symbol to a SEDOL number, call the SEDOL method.

symbol = self.SEDOL("2046251") # AAPL Symbol
sedol = self.SEDOL(symbol) # AAPL SEDOL (2046251)

var symbol = SEDOL("2046251"); // AAPL Symbol
var sedol = SEDOL(symbol); // AAPL SEDOL (2046251)

Introduction

Event handlers are called during an algorithm execution to pass information to your strategy. Most of the events are not needed for simple strategies, but can be helpful for debugging issues in more complex algorithms.

Data Events

public override void OnData(Slice slice)
{
    if (slice.ContainsKey(_symbol))
    {
        var myData = slice[_symbol];
    }
}

def OnData(self, slice: Slice) -> None:
    if slice.ContainsKey(self.symbol):
        my_data = slice[self.symbol]

The OnData method is the primary event handler for receiving financial data events to your algorithm. It is triggered sequentially at the point in time the data is available; in backtesting and live. For daily data this means the event is processed at midnight in backtesting or 6am the following day in live trading.

All data for a given moment of time is grouped in a single event, including custom data types. This data is passed with the Slice object.

When fill-forward is enabled for your asset, the OnData event handler will be called regularly even if there was no new data. This is the default behavior.

If the handler takes a long time to process, events will be queued up and the next event will be triggered again immediately. In live trading it is important to ensure your event handlers process quickly. Perform intensive computation before the market opens with a Scheduled Event , or a Train event.

For more information on the Slice object and OnData event, see Handling Data .

Securities Changed Event

public override void OnSecuritiesChanged(SecurityChanges changes)
{
    foreach (var security in changes.AddedSecurities)
    {
        Debug($"{Time}: Added {security.Symbol}");
    }
    foreach (var security in changes.RemovedSecurities)
    {
        Debug($"{Time}: Removed {security.Symbol}");
        
        if (security.Invested)
        {
            Liquidate(security.Symbol, "Removed from Universe");
        }
    }
}

def OnSecuritiesChanged(self, changes: SecurityChanges) -> None:
    for security in changes.AddedSecurities:
        self.Debug(f"{self.Time}: Added {security.Symbol}")

    for security in changes.RemovedSecurities:
        self.Debug(f"{self.Time}: Removed {security.Symbol}")
        
        if security.Invested:
            self.Liquidate(security.Symbol, "Removed from Universe")

The OnSecuritiesChanged event notifies the algorithm when assets are added or removed from the universe. This can be due to changes in the Universe constituents , or an explicit call to the RemoveSecurity method.

The event is triggered immediately when the asset is removed from the universe; however the data feed for the asset may remain active if the algorithm has open orders.

For more information, see how to use Security Changed Events .

Order Events

public override void OnOrderEvent(OrderEvent orderEvent)
{
    var order = Transactions.GetOrderById(orderEvent.OrderId);
    if (orderEvent.Status == OrderStatus.Filled)
    {
        Debug($"{Time}: {order.Type}: {orderEvent}");
    }
}

public override void OnAssignmentOrderEvent(OrderEvent assignmentEvent)
{
    Log(assignmentEvent.ToString());
}

def OnOrderEvent(self, orderEvent: OrderEvent) -> None:
    order = self.Transactions.GetOrderById(orderEvent.OrderId)
    if orderEvent.Status == OrderStatus.Filled:
        self.Debug(f"{self.Time}: {order.Type}: {orderEvent}")

def OnAssignmentOrderEvent(self, assignmentEvent: OrderEvent) -> None:
    self.Log(str(assignmentEvent))

The OnOrderEvent method notifies the algorithm of new orders, and changes in the order status such as fill events and cancelations. For options assignment events there is a dedicated event handler OnAssignmentOrderEvent .

In backtesting order events are triggered synchronously after the main data events. In live trading, order events are asynchronously as they occur. To avoid infinite loops, we recommend not to place orders in the OnOrderEvent.

For more information, see how to use Order Events .

Brokerage Events

public override void OnBrokerageMessage(BrokerageMessageEvent message)
{
    if (message.Type== BrokerageMessageType.Reconnect)
    {
        Log($"{Time}: {message.Type}: Message: {message.Message}");
    }
}

public override void OnBrokerageDisconnect()
{
    Log($"Brokerage disconnection detected at {Time}.");
}

def OnBrokerageMessage(self, message: BrokerageMessageEvent) -> None: 
    if message.Type == BrokerageMessageType.Reconnect:
        self.Log(f"{self.Time}: {message.Type}: Message: {message.Message}")

def OnBrokerageDisconnect(self) -> None:
    self.Log("Brokerage disconnection detected")

The OnBrokerageDisconnect and OnBrokerageReconnect event handlers pass information to the algorithm about the brokerage connection status. This can be helpful for considering when to place a trade when a brokerage API is unreliable or under maintenance. The OnBrokerageMessage event handler provides information from the brokerages, including the disconnect and reconnect messages. Message content varies with each brokerage.

Brokerage events are triggered asynchronously in live trading, and are not created in backtesting.

Margin Call Events

public override void OnMarginCall(List requests)
{
    foreach (var orderRequest in requests) {
    }
}

public override void OnBrokerageDisconnect()
{
    Log($"Brokerage disconnection detected at {Time}.");
}

def OnMarginCall(self, requests): -> List[SubmitOrderRequest]: 
    # Modify order requests to choose what to liquidate.
    return requests

def OnMarginCallWarning()(self) -> None:
    self.Log("Margin call warning, 5% margin remaining")

The OnMarginCallWarning and OnMarginCall event handlers provide information and control over how to reduce algorithm leverage when performance is poor.

The OnMarginCallWarning method is called when there is less than 5% margin remaining, this gives you an opportunity to reduce leverage before an official margin call is performed by the brokerage. The OnMarginCall event handler is passed a list of SubmitOrderRequest objects which will be executed on exiting the method.

Margin events are called before the data events are processed.

The following demonstration demonstration processes suggested orders and modifies the qualities to liquidate more than necessary and prevent a second margin call. For more information, see how to handle Margin Calls .

Warmup Finished Event

public override void OnWarmupFinished()
{
    // Done warming up
}

def OnWarmupFinished(self) -> None:
    pass # Done warming up

The OnWarmupFinished event handler is triggered after initialization, and warm up is complete. This event signals that the initialization of the algorithm is complete.

For more information, see how to use Warm Up to prepare your algorithm.

End Of Algorithm Events

def OnEndOfAlgorithm(self) -> None:
    self.Debug("Algorithm done")

public override void OnEndOfAlgorithm()
{
    Debug("Algorithm done");
}

The OnEndOfAlgorithm event handler is when the algorithm has finished executing as its final step. This is helpful for performing final analysis, or saving algorithm state.

Event Flow

When you deploy an algorithm, LEAN first calls the Initialize method. In live mode, the engine loads your holdings and open orders from your brokerage account to add data subscriptions and populate the Securities , Portfolio , and Transactions objects. LEAN receives the data from the subscriptions, synchronizes the data to create a timeslice , and then performs the following steps. Your algorithm can spend up to 10 minutes on each timeslice unless you call the Train method.

1. If it's a backtest, check if there are Scheduled Events in the past that didn't fire because there was no data between the previous slice and the current slice. LEAN automatically creates a Scheduled Event to call the OnEndOfDay method at the end of each day.

In live mode, Scheduled Events occur in a separate thread from the algorithm manager, so they run at the correct time.

2. Update the algorithm time.
3. Update the CurrentSlice .
4. Cancel all open orders for securities that changed their ticker .
5. Add a Security object to the Securities collection for each new security in the universe.
6. Update the Security objects with the latest data.
7. Update the Cash objects in the CashBook with the latest data.
8. Process fill models for non-market orders.
   
9. Submit market on open orders to liquidate Equity Option contracts if the underlying Equity has a split warning .
10. Process margin calls .
    
11. If it's time to settle unsettled cash , perform settlement.
12. Call the OnSecuritiesChanged method with the latest security changes.
13. Apply dividends to the portfolio.
14. For securities that have a split warning, update their portfolio holdings and adjust their open orders to account for the split.
15. Update consolidators with the latest data.
    
16. Pass custom data to the OnData method.
17. Pass Dividends to the OnData method.
18. Pass Splits to the OnData method.
19. Pass Delistings to the OnData method.
20. Pass TradeBars to the OnData method.
21. Pass QuoteBars to the OnData method.
22. Pass OptionChains to the OnData method.
23. Pass Ticks to the OnData method.
24. Pass the Slice to the OnData method.
25. Perform universe selection .
26. Pass the Slice to the Update method of each Alpha model .
27. Pass the Insight objects from the Alpha model to the Portfolio Construction model .
28. Pass the PortfolioTarget objects from the Portfolio Construction model to each Risk Management model .
29. Pass the risk-adjusted PortfolioTarget objects from the Risk Management models to the Execution model .

When your algorithm stops executing, LEAN calls the OnEndOfAlgorithm method .

Introduction

The LEAN open-source package powers the core functionality of QuantConnect. Strategies plugin to LEAN to request data, and process trades. LEAN is written in C# and accessed in python with a defined API. Most of these interactions are using native python types, with a few key exceptions. To comfortably use LEAN you should learn to recognize error messages when you hit a non-native API, and how to convert back to a native type.

Enumerable Types

When LEAN returns an enumerable, the object should be converted to a list() to be easily read by python classes. Popular API methods which return an enumerable are shown below:

Historical Data

QuantConnect also provides methods to request historical data that return a pandas dataframe, or an enumerable. If loading a large amount of data using an enumerable streams the results reducing RAM usage.

The enumerable types might look like the MemoizingEnumerable that is a raw C# type accessible in python.

You can directly enumerate this object with standard python for loops, or to convert it to a native type, wrap the object in the list() :

Underlying Plugin Architecture

Your strategy code implements the QCAlgorithm class, which can communicate with the LEAN Engine. These method calls are done at the same speed as cython, directly invoking calls at the C layer of python. Your algorithm is imported as syntax checked, interpreted python.

Introduction

We aim to teach and inspire our community to create high-performing algorithmic trading strategies. We measure our success by the profits community members create through their live trading. As such, we try to build the best quantitative research techniques possible into the product to encourage a robust research process.

Hypothesis-Driven Research

We recommend you develop an algorithmic trading strategy based on a central hypothesis. You should develop an algorithm hypothesis at the start of your research and spend the remaining time exploring how to test your theory. If you find yourself deviating from your core theory or introducing code that isn't based around that hypothesis, you should stop and go back to thesis development.

Wang et al. (2014) illustrate the danger of creating your hypothesis based on test results. In their research, they examined the earnings yield factor in the technology sector over time. During 1998-1999, before the tech bubble burst, the factor was unprofitable. If you saw the results and then decided to bet against the factor during 2000-2002, you would have lost a lot of money because the factor performed extremely well during that time.

Hypothesis development is somewhat of an art and requires creativity and great observation skills. It is one of the most powerful skills a quant can learn. We recommend that an algorithm hypothesis follow the pattern of cause and effect. Your aim should be to express your strategy in the following sentence:

A change in {cause} leads to an {effect}.

To search for inspiration, consider causes from your own experience, intuition, or the media. Generally, causes of financial market movements fall into the following categories:

• Human psychology
• Real-world events/fundamentals
• Invisible financial actions

Consider the following examples:

There are millions of potential alpha strategies to explore, each of them a candidate for an algorithm. Once you have chosen a strategy, we recommend exploring it for no more than 8-32 hours, depending on your coding ability.

Data Mining Driven Research

An alternative view is to follow any statistical anomaly without explaining it. In this case, you can use statistical techniques to identify the discontinuities and eliminate them when their edge is gone. Apparently, Renaissance Technologies has data mining models like this.

Overfitting

Overfitting occurs when you fine-tune the parameters of an algorithm to fit the detail and noise of backtesting data to the extent that it negatively impacts the performance of the algorithm on new data. The problem is that the parameters don't necessarily apply to new data and thus negatively impact the algorithm's ability to generalize and trade well in all market conditions. The following table shows ways that overfitting can manifest itself:

An algorithm that is dynamic and generalizes to new data is more valuable to funds and individual investors. It is more likely to survive across different market conditions and apply to new asset classes and markets.

If you have a collection of factors, you can backtest over a period of time to find the best-performing factors for the time period. If you then narrow the collection of factors to just the best-performing ones and backtest over the same period, the backtest will show great results. However, if you take the same best-performing factors and backtest them on an out-of-sample dataset, the performance will almost always underperform the in-sample period. To avoid issues with overfitting, follow these guidelines:

• Use walk-forward optimization to train your models on historical data and test them on future data.
• Test your strategy with live paper trading.
• Test your model on different asset classes and markets.

Look-ahead Bias

Look-ahead bias occurs when you use information from the future to inform decisions in the present. An example of look-ahead bias is using financial statement data to make trading decisions at the end of the reporting period instead of when the financial statement data was released. Another example is using updated financial statement data before the updated figures were actually available. Wang et al. (2014) show that using the date of when the period ends instead of when the data is actually available can increase the performance of the earnings yield factor by 60%.

Another culprit of look-ahead bias is adjusted price data. Splits and reverse splits can improve liquidity or attract certain investors, causing the performance of the stock to be different than without the split or reverse split. Wang et al (2014) build a portfolio using the 25 lowest priced stocks in the S&P index based on adjusted and non-adjusted prices. The portfolio based on adjusted prices greatly outperformed the one with raw prices in terms of return and Sharpe ratio . In this case, if you were to analyze the low price factor with adjusted prices, it would lead you to believe the factor is very informative, but it would not perform well out-of-sample with raw data.

Look-ahead bias can also occur if you set the universe to assets that have performed well during the backtest period or initialize indicators with values that have performed well during the backtest period. To avoid issues with look-ahead bias, trade a dynamic universe of assets and use point-in-time data. If point-in-time data is not available for the dataset you use, apply a reporting lag. Since the backtesting environment is event-driven and you can't pass the time frontier, it naturally helps to reduce the risk of look-ahead bias.

Survivorship Bias

Survivorship bias occurs when you test a strategy using only the securities that have survived to the end of the testing period and omit securities that have been delisted. If you use the current constituents of an index and backtest over the past, you'll most likely outperform the index because many of the underperformers have dropped out of the index over time and outperformers have been added to the index. In this case, the current constituent universe would consist of only outperformers. This technique is a form of look-ahead bias because if you were trading the strategy in real-time throughout the backtest period, you would not know the current index constituents until today.

If you analyze a dataset that has survivorship bias, you can discover results that are opposite of the true results. For example, Wang et al. (2014) analyze the low volatility factor using two universes. The first universe was the current S&P 500 constituents and the second universe was the point-in-time constituents. When they used the point-in-time constituents, the low volatility quintile outperformed the high volatility quintile. However, when they used the current constituents, the high volatility quintile significantly outperformed the low volatility quintile.

To avoid issues with survivorship bias, trade a dynamic universe of assets and use the datasets in the Dataset Market . We thoroughly vet the datasets we add to the market to ensure they're free of survivorship bias.

Outliers

Outliers in a dataset can have large impacts on how models train. In some cases, you may leave outliers in a dataset because they can contain useful information. In other cases, you may want to transform the data to handle the outlier data points. There are several common methods to handle outliers.

Winsorization Method

The winsorization method removes outliers at the $x$% of the extremes. For example, if you winsorize at 1%, it removes the 1% of data points with the lowest value and the 1% of data points with the highest value. This threshold percentage is subjective, so it can result in overfitting.

IQR Method

The interquartile range method removes data points that fall outside of the interval \([Q_1 - k (Q_3 - Q_1),\ Q_3 + k (Q_3 - Q_1)]\) for some constant \(k\ge 0\). This method can exclude up to 25% of observations on each side of the extremes. The interquartile range method doesn't work if the data is skewed or non-normal. Therefore, the disadvantage to this method is you need to review the factor distribution properties. If you need to, you can normalize the data with z-scores.

Factor Ranking Method

The factor ranking method ranks the data values instead of taking their raw values. With this method, you don't need to remove any outlier data points. This method transforms the data into a uniform distribution. After converting the data to a uniform distribution, Wang et al. (2014) perform an inverse normal transformation to make the factor values normally distributed. Wang et al. found this ranking technique outperforms the z-score transformation, suggesting that the distance between factor scores doesn't add useful information.

Introduction

Libraries (or packages) are third-party software that you can use in your projects. You can use many of the available open-source libraries to complement the classes and methods that you create. Libraries reduce your development time because it's faster to use a pre-built, open-source library than to write the functionality. Libraries can be used in backtesting, research, and live trading. The environments support various libraries for machine learning, plotting, and data processing. As members often request new libraries, we frequently add new libraries to the underlying docker image that runs the Lean engine.

This feature is primarily for Python algorithms as not all Python libraries are compatible with each other. We've bundled together different sets of libraries into distinct environments. To use the libraries of an environment, set the environment in your project and add the relevant using import statement of a library at the top of your file.

Default Environment Libraries

The default environment supports the following libraries:

# Name                        Version
absl-py                       1.4.0
adagio                        0.2.4
aesara                        2.8.12
aiodns                        3.0.0
aiohttp                       3.8.4
aiohttp-cors                  0.7.0
aiosignal                     1.3.1
alabaster                     0.7.13
ale-py                        0.7.4
alembic                       1.10.3
alpaca-trade-api              0.26
alphalens-reloaded            0.4.3
altair                        4.2.2
ansi2html                     1.8.0
antlr4-python3-runtime        4.11.1
anyio                         3.6.2
appdirs                       1.4.4
arch                          5.3.1
argon2-cffi                   21.3.0
argon2-cffi-bindings          21.2.0
arviz                         0.15.1
astropy                       5.2.1
asttokens                     2.2.1
astunparse                    1.6.3
async-timeout                 4.0.2
asyncio-nats-client           0.11.5
attrs                         23.1.0
autograd                      1.5
autokeras                     1.1.0
autoray                       0.6.3
AutoROM                       0.4.2
AutoROM.accept-rom-license    0.6.1
ax-platform                   0.3.0
Babel                         2.12.1
backcall                      0.2.0
bayesian-optimization         1.4.2
beautifulsoup4                4.11.2
bleach                        6.0.0
blessed                       1.20.0
blis                          0.7.9
blosc2                        2.0.0
bokeh                         2.4.3
boltons                       23.0.0
botorch                       0.8.2
Bottleneck                    1.3.7
brotlipy                      0.7.0
cachetools                    5.3.0
captum                        0.6.0
catalogue                     2.0.8
catboost                      1.1.1
category-encoders             2.6.0
ccxt                          3.0.72
certifi                       2022.12.7
cffi                          1.15.1
chardet                       5.1.0
charset-normalizer            2.0.4
check-shapes                  1.0.0
click                         7.1.2
clikit                        0.6.2
cloudpickle                   2.2.1
cmaes                         0.9.1
cmdstanpy                     1.1.0
colorama                      0.4.6
colorcet                      3.0.1
colorful                      0.5.5
colorlog                      6.7.0
colorlover                    0.3.0
colour                        0.1.5
comm                          0.1.3
commonmark                    0.9.1
conda                         23.3.1
conda-content-trust           0.1.3
conda-package-handling        2.0.2
conda_package_streaming       0.7.0
confection                    0.0.4
cons                          0.4.5
contourpy                     1.0.7
convertdate                   2.4.0
copulae                       0.7.7
copulas                       0.8.0
cramjam                       2.6.2
crashtest                     0.3.1
creme                         0.6.1
cryptography                  38.0.4
cufflinks                     0.17.3
cvxopt                        1.3.0
cvxpy                         1.3.0
cycler                        0.11.0
cymem                         2.0.7
Cython                        0.29.33
darts                         0.23.1
dash                          2.9.3
dash-core-components          2.0.0
dash-cytoscape                0.3.0
dash-html-components          2.0.0
dash-table                    5.0.0
dask                          2023.4.0
deap                          1.3.3
debugpy                       1.5.1
decorator                     5.1.1
defusedxml                    0.7.1
Deprecated                    1.2.13
dgl                           1.0.1
dill                          0.3.6
dimod                         0.12.3
diskcache                     5.6.1
distlib                       0.3.6
distributed                   2021.4.1
dm-tree                       0.1.8
docutils                      0.19
DoubleML                      0.5.2
dtreeviz                      2.2.1
dtw-python                    1.3.0
dwave-cloud-client            0.10.3
dwave-drivers                 0.4.4
dwave-greedy                  0.3.0
dwave-hybrid                  0.6.9
dwave-inspector               0.3.0
dwave-inspectorapp            0.3.0
dwave-neal                    0.6.0
dwave-networkx                0.8.12
dwave-ocean-sdk               6.1.1
dwave-preprocessing           0.5.3
dwave-samplers                1.0.0
dwave-system                  1.18.0
dwave-tabu                    0.5.0
dwavebinarycsp                0.2.0
dx                            0.1.22
ecos                          2.0.12
EMD-signal                    1.4.0
empyrical                     0.5.5
empyrical-reloaded            0.5.9
en-core-web-md                3.5.0
en-core-web-sm                3.5.0
entrypoints                   0.4
ephem                         4.1.4
et-xmlfile                    1.1.0
etuples                       0.3.8
exceptiongroup                1.1.1
exchange-calendars            4.2.6
executing                     1.2.0
ezyrb                         1.3.0.post2304
fastai                        2.7.11
fastai2                       0.0.30
fastcore                      1.5.29
fastdownload                  0.0.7
fasteners                     0.18
fastjsonschema                2.16.3
fastparquet                   2023.2.0
fastprogress                  1.0.3
fasttext                      0.9.2
featuretools                  0.23.1
filelock                      3.12.0
findiff                       0.9.2
finrl                         0.3.1
FixedEffectModel              0.0.5
Flask                         2.0.3
flatbuffers                   23.3.3
fonttools                     4.39.3
fracdiff                      0.9.0
frozendict                    2.3.7
frozenlist                    1.3.3
fs                            2.4.16
fsspec                        2023.4.0
fst-pso                       1.8.1
fugue                         0.8.3
fugue-sql-antlr               0.1.6
future                        0.18.3
fuzzy-c-means                 1.6.3
FuzzyTM                       2.0.5
gast                          0.4.0
gensim                        4.3.0
gevent                        22.10.2
gluonts                       0.12.3
google-api-core               2.11.0
google-auth                   2.17.3
google-auth-oauthlib          0.4.6
google-pasta                  0.2.0
googleapis-common-protos      1.59.0
gpflow                        2.7.0
gplearn                       0.4.2
gpustat                       1.1
GPUtil                        1.4.0
gpytorch                      1.9.1
graphviz                      0.20.1
greenlet                      2.0.2
grpcio                        1.54.0
gym                           0.21.0
Gymnasium                     0.26.3
gymnasium-notices             0.0.1
h2o                           3.40.0.1
h5netcdf                      1.1.0
h5py                          3.8.0
hijri-converter               2.2.4
hmmlearn                      0.2.8
holidays                      0.23
holoviews                     1.15.4
homebase                      1.0.1
hopcroftkarp                  1.2.5
html5lib                      1.1
httpstan                      4.9.1
hurst                         0.0.5
hvplot                        0.8.2
hyperopt                      0.2.7
idna                          3.4
iisignature                   0.24
ijson                         3.2.0.post0
imageio                       2.27.0
imagesize                     1.4.1
imbalanced-learn              0.10.1
importlib-metadata            4.13.0
importlib-resources           5.12.0
iniconfig                     2.0.0
injector                      0.20.1
interpret                     0.3.0
interpret-core                0.3.2
ipykernel                     6.22.0
ipython                       8.12.0
ipython-genutils              0.2.0
ipywidgets                    8.0.4
itsdangerous                  2.1.2
jax                           0.4.4
jaxlib                        0.4.4
jedi                          0.18.2
Jinja2                        3.1.2
joblib                        1.2.0
jqdatasdk                     1.8.11
json5                         0.9.11
jsonpatch                     1.32
jsonpointer                   2.0
jsonschema                    4.17.3
jupyter                       1.0.0
jupyter-bokeh                 3.0.5
jupyter-console               6.6.3
jupyter-dash                  0.4.2
jupyter-resource-usage        0.7.2
jupyter-server                1.24.0
jupyter_client                8.2.0
jupyter_core                  5.3.0
jupyterlab                    3.4.4
jupyterlab-pygments           0.2.2
jupyterlab-widgets            3.0.7
jupyterlab_server             2.22.1
keract                        4.5.1
keras                         2.11.0
keras-nlp                     0.4.1
keras-rl                      0.4.2
keras-tuner                   1.3.5
kiwisolver                    1.4.4
kmapper                       2.0.1
korean-lunar-calendar         0.3.1
kt-legacy                     1.0.5
langcodes                     3.3.0
lark                          1.1.5
lazy_loader                   0.2
lazypredict                   0.2.12
libclang                      16.0.0
lightgbm                      3.3.5
lime                          0.2.0.1
line-profiler                 4.0.2
linear-operator               0.3.0
littleutils                   0.2.2
livelossplot                  0.5.5
llvmlite                      0.39.1
locket                        1.0.0
logical-unification           0.4.5
LunarCalendar                 0.0.9
lxml                          4.9.2
lz4                           4.3.2
Mako                          1.2.4
Markdown                      3.4.3
MarkupSafe                    2.1.2
marshmallow                   3.19.0
matplotlib                    3.7.0
matplotlib-inline             0.1.6
miniful                       0.0.6
miniKanren                    1.0.3
minorminer                    0.2.9
mistune                       2.0.5
mljar-supervised              0.11.5
mlxtend                       0.21.0
mmh3                          2.5.1
modin                         0.18.1
mpi4py                        3.1.4
mplfinance                    0.12.9b7
mpmath                        1.2.1
msgpack                       1.0.4
mthree                        2.4.0
multidict                     6.0.4
multipledispatch              0.6.0
multiprocess                  0.70.14
multitasking                  0.0.11
murmurhash                    1.0.9
nbclassic                     0.5.5
nbclient                      0.7.3
nbconvert                     7.3.1
nbeats-keras                  1.8.0
nbeats-pytorch                1.8.0
nbformat                      5.8.0
nest-asyncio                  1.5.6
networkx                      2.8.8
neural-tangents               0.6.2
neuralprophet                 0.5.0
nfoursid                      1.0.1
nltk                          3.8.1
nose                          1.3.7
notebook                      6.5.4
notebook_shim                 0.2.2
ntlm-auth                     1.5.0
numba                         0.56.4
numerapi                      2.13.2
numexpr                       2.8.4
numpy                         1.23.5
numpydoc                      1.5.0
nvidia-cublas-cu11            11.10.3.66
nvidia-cuda-nvrtc-cu11        11.7.99
nvidia-cuda-runtime-cu11      11.7.99
nvidia-cudnn-cu11             8.5.0.96
nvidia-ml-py                  11.525.112
oauthlib                      3.2.2
openai                        0.26.5
opencensus                    0.11.2
opencensus-context            0.1.3
opencv-python                 4.7.0.72
openpyxl                      3.1.1
opt-einsum                    3.3.0
optuna                        3.1.0
orjson                        3.8.10
ortools                       9.4.1874
osqp                          0.6.2.post9
outdated                      0.2.2
packaging                     23.1
pandas                        1.5.3
pandas-datareader             0.10.0
pandas-flavor                 0.5.0
pandas-market-calendars       4.1.4
pandas-ta                     0.3.14b0
pandocfilters                 1.5.0
panel                         0.14.3
param                         1.13.0
parso                         0.8.3
partd                         1.4.0
pastel                        0.2.1
pathos                        0.3.0
pathy                         0.10.1
patsy                         0.5.3
pbr                           5.11.1
penaltymodel                  1.0.2
PennyLane                     0.29.0
PennyLane-Lightning           0.29.0
PennyLane-qiskit              0.29.0
persim                        0.3.1
pexpect                       4.8.0
pickleshare                   0.7.5
Pillow                        9.5.0
pingouin                      0.5.3
pip                           22.3.1
pkgutil_resolve_name          1.3.10
platformdirs                  3.2.0
plotly                        5.13.1
plotly-resampler              0.8.3.2
plucky                        0.4.3
pluggy                        1.0.0
ply                           3.11
pmdarima                      2.0.2
polars                        0.16.9
pox                           0.3.2
ppft                          1.7.6.6
pprofile                      2.1.0
ppscore                       1.2.0
preshed                       3.0.8
prometheus-client             0.16.0
prompt-toolkit                3.0.38
property-cached               1.6.4
prophet                       1.1.2
protobuf                      3.19.6
psutil                        5.9.5
psycopg2-binary               2.9.6
ptvsd                         4.3.2
ptyprocess                    0.7.0
PuLP                          2.7.0
pure-eval                     0.2.2
py-cpuinfo                    9.0.0
py-heat                       0.0.6
py-heat-magic                 0.0.2
py-lets-be-rational           1.0.1
py-spy                        0.3.14
py-vollib                     1.0.1
py4j                          0.10.9.7
pyaml                         21.10.1
pyarrow                       11.0.0
pyasn1                        0.4.8
pyasn1-modules                0.2.8
pybind11                      2.10.4
pycares                       4.3.0
pycosat                       0.6.4
pycparser                     2.21
pyct                          0.5.0
pydantic                      1.10.7
pyDeprecate                   0.3.2
pydevd-pycharm                201.8538.36
pydmd                         0.4.0.post2301
pyerfa                        2.0.0.3
pyfolio                       0.9.2
pyfolio-reloaded              0.9.5
pyFUME                        0.2.25
Pygments                      2.15.1
pykalman                      0.9.5
pylev                         1.4.0
pyluach                       2.2.0
pymannkendall                 1.4.3
pymc                          5.0.2
pymdptoolbox                  4.0b3
PyMeeus                       0.5.12
PyMySQL                       1.0.3
pynndescent                   0.5.9
pyod                          1.0.9
Pyomo                         6.5.0
pyOpenSSL                     22.0.0
pyparsing                     3.0.9
pyportfolioopt                1.5.4
pyqubo                        1.3.1
pyrb                          1.0.1
pyro-api                      0.1.2
pyro-ppl                      1.8.4
pyrsistent                    0.19.3
pysimdjson                    5.0.2
PySocks                       1.7.1
pystan                        3.6.0
pytensor                      2.9.1
pytest                        7.3.1
python-dateutil               2.8.2
python-statemachine           1.0.3
pytorch-ignite                0.4.11
pytorch-lightning             1.7.4
pytz                          2023.3
pyvinecopulib                 0.6.2
pyviz-comms                   2.2.1
PyWavelets                    1.4.1
PyYAML                        6.0
pyzmq                         25.0.2
qdldl                         0.1.7
qiskit                        0.41.1
qiskit-aer                    0.11.2
qiskit-ibmq-provider          0.20.1
qiskit-terra                  0.23.2
qpd                           0.4.1
qtconsole                     5.4.2
QtPy                          2.3.1
quadprog                      0.1.11
quantecon                     0.6.0
QuantLib                      1.29
QuantStats                    0.0.59
rauth                         0.7.3
ray                           2.3.0
rectangle-packer              2.0.1
regex                         2023.3.23
requests                      2.28.1
requests-ntlm                 1.1.0
requests-oauthlib             1.3.1
retrying                      1.3.4
retworkx                      0.12.1
rich                          12.4.4
ripser                        0.6.4
Riskfolio-Lib                 4.0.3
riskparityportfolio           0.4
river                         0.14.0
rsa                           4.9
ruamel.yaml                   0.17.21
ruamel.yaml.clib              0.2.6
ruptures                      1.1.7
rustworkx                     0.12.1
SALib                         1.4.7
scikeras                      0.10.0
scikit-image                  0.19.3
scikit-learn                  1.2.1
scikit-learn-extra            0.2.0
scikit-multiflow              0.5.3
scikit-optimize               0.9.0
scikit-plot                   0.3.7
scikit-tda                    1.0.0
scipy                         1.10.1
scs                           3.2.3
sdeint                        0.3.0
seaborn                       0.12.2
semantic-version              2.10.0
Send2Trash                    1.8.0
setuptools                    64.0.2
setuptools-scm                7.1.0
shap                          0.41.0
simpful                       2.10.0
simplejson                    3.19.1
simpy                         4.0.1
six                           1.16.0
sklearn-json                  0.1.0
skope-rules                   1.0.1
sktime                        0.16.1
slicer                        0.0.7
smart-open                    6.3.0
sniffio                       1.3.0
snowballstemmer               2.2.0
sortedcontainers              2.4.0
soupsieve                     2.4.1
spacy                         3.5.0
spacy-legacy                  3.0.12
spacy-loggers                 1.0.4
Sphinx                        6.1.3
sphinxcontrib-applehelp       1.0.4
sphinxcontrib-devhelp         1.0.2
sphinxcontrib-htmlhelp        2.0.1
sphinxcontrib-jsmath          1.0.1
sphinxcontrib-qthelp          1.0.3
sphinxcontrib-serializinghtml 1.1.5
SQLAlchemy                    1.4.47
sqlglot                       11.5.5
srsly                         2.4.6
ssm                           0.0.1
stable-baselines3             1.7.0
stack-data                    0.6.2
statsforecast                 1.5.0
statsmodels                   0.13.5
stellargraph                  1.2.1
stevedore                     5.0.0
stochastic                    0.7.0
stockstats                    0.5.2
stumpy                        1.11.1
symengine                     0.10.0
sympy                         1.11.1
ta                            0.10.2
TA-Lib                        0.4.18
tables                        3.8.0
tabulate                      0.8.10
tadasets                      0.0.4
tbats                         1.1.3
tblib                         1.7.0
tenacity                      8.2.2
tensorboard                   2.11.2
tensorboard-data-server       0.6.1
tensorboard-plugin-wit        1.8.1
tensorboardX                  2.6
tensorflow                    2.11.0
tensorflow-addons             0.19.0
tensorflow-decision-forests   1.2.0
tensorflow-estimator          2.11.0
tensorflow-hub                0.13.0
tensorflow-io-gcs-filesystem  0.32.0
tensorflow-probability        0.19.0
tensorflow-text               2.11.0
tensorly                      0.8.0
tensortrade                   1.0.3
termcolor                     2.2.0
terminado                     0.17.1
tf2jax                        0.3.3
thinc                         8.1.9
threadpoolctl                 3.1.0
thriftpy2                     0.4.16
thundergbm                    0.3.17
tick                          0.7.0.1
tifffile                      2023.4.12
tinycss2                      1.2.1
toml                          0.10.2
tomli                         2.0.1
toolz                         0.12.0
torch                         1.13.1
torch-cluster                 1.6.0
torch-geometric               2.2.0
torch-scatter                 2.1.0
torch-sparse                  0.6.16
torch-spline-conv             1.2.1
torchmetrics                  0.9.3
torchvision                   0.14.1
tornado                       6.3
tqdm                          4.64.1
trace-updater                 0.0.9.1
trading-calendars             2.1.1
traitlets                     5.9.0
treeinterpreter               0.2.3
triad                         0.8.6
tsfresh                       0.20.0
tslearn                       0.5.3.2
tweepy                        4.10.0
typeguard                     3.0.2
typer                         0.3.2
typing_extensions             4.5.0
umap-learn                    0.5.3
urllib3                       1.26.14
virtualenv                    20.21.0
wasabi                        1.1.1
wcwidth                       0.2.6
webargs                       8.2.0
webencodings                  0.5.1
websocket-client              1.5.1
websockets                    10.4
Werkzeug                      2.2.3
wheel                         0.37.1
widgetsnbextension            4.0.7
wordcloud                     1.8.2.2
wrapt                         1.14.1
wrds                          3.1.6
wurlitzer                     3.0.3
xarray                        2023.1.0
xarray-einstats               0.5.1
xgboost                       1.7.4
xlrd                          2.0.1
XlsxWriter                    3.1.0
yarl                          1.8.2
yellowbrick                   1.5
yfinance                      0.2.18
zict                          3.0.0
zipp                          3.15.0
zope.event                    4.6
zope.interface                6.0
zstandard                     0.18.0

# Name                               Version
Accord                               3.6.0
Accord.Fuzzy                         3.6.0
Accord.MachineLearning               3.6.0
Accord.Math                          3.6.0
Accord.Statistics                    3.6.0
CloneExtensions                      1.3.0
Common.Logging                       3.4.1
Common.Logging.Core                  3.4.1
CsvHelper                            19.0.0
Deedle                               2.1.0
DotNetZip                            1.16.0
DynamicInterop                       0.9.1
fasterflect                          3.0.0
FSharp.Core                          4.5.2
MathNet.Numerics                     4.15.0
McMaster.Extensions.CommandLineUtils 2.6.0
Microsoft.IO.RecyclableMemoryStream  2.3.1
Microsoft.NET.Test.Sdk               16.9.4
Microsoft.TestPlatform.ObjectModel   16.9.4
Moq                                  4.16.1
NetMQ                                4.0.1.6
Newtonsoft.Json                      13.0.2
NodaTime                             3.0.5
NUnit                                3.13.3
NUnit3TestAdapter                    4.2.1
protobuf-net                         3.1.33
QLNet                                1.12.0
QuantConnect.pythonnet               2.0.18
RestSharp                            106.12.0
SharpZipLib                          1.3.3
System.ComponentModel.Composition    6.0.0

Pomegranate Environment Libraries

The Pomegranate environment cannot be selected on C# projects.

The Pomegranate environment supports the following libraries:

# Name                        Version
absl-py                       1.4.0
adagio                        0.2.4
aesara                        2.8.12
aiodns                        3.0.0
aiohttp                       3.8.4
aiohttp-cors                  0.7.0
aiosignal                     1.3.1
alabaster                     0.7.13
ale-py                        0.7.4
alembic                       1.10.3
alpaca-trade-api              0.26
alphalens-reloaded            0.4.3
altair                        4.2.2
ansi2html                     1.8.0
antlr4-python3-runtime        4.11.1
anyio                         3.6.2
appdirs                       1.4.4
arch                          5.3.1
argon2-cffi                   21.3.0
argon2-cffi-bindings          21.2.0
arviz                         0.15.1
astropy                       5.2.1
asttokens                     2.2.1
astunparse                    1.6.3
async-timeout                 4.0.2
asyncio-nats-client           0.11.5
attrs                         23.1.0
autograd                      1.5
autokeras                     1.1.0
autoray                       0.6.3
AutoROM                       0.4.2
AutoROM.accept-rom-license    0.6.1
ax-platform                   0.3.0
Babel                         2.12.1
backcall                      0.2.0
bayesian-optimization         1.4.2
beautifulsoup4                4.11.2
bleach                        6.0.0
blessed                       1.20.0
blis                          0.7.9
blosc2                        2.0.0
bokeh                         2.4.3
boltons                       23.0.0
botorch                       0.8.2
Bottleneck                    1.3.7
brotlipy                      0.7.0
cachetools                    5.3.0
captum                        0.6.0
catalogue                     2.0.8
catboost                      1.1.1
category-encoders             2.6.0
ccxt                          3.0.72
certifi                       2022.12.7
cffi                          1.15.1
chardet                       5.1.0
charset-normalizer            2.0.4
check-shapes                  1.0.0
click                         7.1.2
clikit                        0.6.2
cloudpickle                   2.2.1
cmaes                         0.9.1
cmdstanpy                     1.1.0
colorama                      0.4.6
colorcet                      3.0.1
colorful                      0.5.5
colorlog                      6.7.0
colorlover                    0.3.0
colour                        0.1.5
comm                          0.1.3
commonmark                    0.9.1
conda                         23.3.1
conda-content-trust           0.1.3
conda-package-handling        2.0.2
conda_package_streaming       0.7.0
confection                    0.0.4
cons                          0.4.5
contourpy                     1.0.7
convertdate                   2.4.0
copulae                       0.7.7
copulas                       0.8.0
cramjam                       2.6.2
crashtest                     0.3.1
creme                         0.6.1
cryptography                  38.0.4
cufflinks                     0.17.3
cvxopt                        1.3.0
cvxpy                         1.3.0
cycler                        0.11.0
cymem                         2.0.7
Cython                        0.29.33
darts                         0.23.1
dash                          2.9.3
dash-core-components          2.0.0
dash-cytoscape                0.3.0
dash-html-components          2.0.0
dash-table                    5.0.0
dask                          2023.4.0
deap                          1.3.3
debugpy                       1.5.1
decorator                     5.1.1
defusedxml                    0.7.1
Deprecated                    1.2.13
dgl                           1.0.1
dill                          0.3.6
dimod                         0.12.3
diskcache                     5.6.1
distlib                       0.3.6
distributed                   2021.4.1
dm-tree                       0.1.8
docutils                      0.19
DoubleML                      0.5.2
dtreeviz                      2.2.1
dtw-python                    1.3.0
dwave-cloud-client            0.10.3
dwave-drivers                 0.4.4
dwave-greedy                  0.3.0
dwave-hybrid                  0.6.9
dwave-inspector               0.3.0
dwave-inspectorapp            0.3.0
dwave-neal                    0.6.0
dwave-networkx                0.8.12
dwave-ocean-sdk               6.1.1
dwave-preprocessing           0.5.3
dwave-samplers                1.0.0
dwave-system                  1.18.0
dwave-tabu                    0.5.0
dwavebinarycsp                0.2.0
dx                            0.1.22
ecos                          2.0.12
EMD-signal                    1.4.0
empyrical                     0.5.5
empyrical-reloaded            0.5.9
en-core-web-md                3.5.0
en-core-web-sm                3.5.0
entrypoints                   0.4
ephem                         4.1.4
et-xmlfile                    1.1.0
etuples                       0.3.8
exceptiongroup                1.1.1
exchange-calendars            4.2.6
executing                     1.2.0
ezyrb                         1.3.0.post2304
fastai                        2.7.11
fastai2                       0.0.30
fastcore                      1.5.29
fastdownload                  0.0.7
fasteners                     0.18
fastjsonschema                2.16.3
fastparquet                   2023.2.0
fastprogress                  1.0.3
fasttext                      0.9.2
featuretools                  0.23.1
filelock                      3.12.0
findiff                       0.9.2
finrl                         0.3.1
FixedEffectModel              0.0.5
Flask                         2.0.3
flatbuffers                   23.3.3
fonttools                     4.39.3
fracdiff                      0.9.0
frozendict                    2.3.7
frozenlist                    1.3.3
fs                            2.4.16
fsspec                        2023.4.0
fst-pso                       1.8.1
fugue                         0.8.3
fugue-sql-antlr               0.1.6
future                        0.18.3
fuzzy-c-means                 1.6.3
FuzzyTM                       2.0.5
gast                          0.4.0
gensim                        4.3.0
gevent                        22.10.2
gluonts                       0.12.3
google-api-core               2.11.0
google-auth                   2.17.3
google-auth-oauthlib          0.4.6
google-pasta                  0.2.0
googleapis-common-protos      1.59.0
gpflow                        2.7.0
gplearn                       0.4.2
gpustat                       1.1
GPUtil                        1.4.0
gpytorch                      1.9.1
graphviz                      0.8.4
greenlet                      2.0.2
grpcio                        1.54.0
gym                           0.21.0
Gymnasium                     0.26.3
gymnasium-notices             0.0.1
h2o                           3.40.0.1
h5netcdf                      1.1.0
h5py                          3.8.0
hijri-converter               2.2.4
hmmlearn                      0.2.8
holidays                      0.23
holoviews                     1.15.4
homebase                      1.0.1
hopcroftkarp                  1.2.5
html5lib                      1.1
httpstan                      4.9.1
hurst                         0.0.5
hvplot                        0.8.2
hyperopt                      0.2.7
idna                          3.4
iisignature                   0.24
ijson                         3.2.0.post0
imageio                       2.27.0
imagesize                     1.4.1
imbalanced-learn              0.10.1
importlib-metadata            4.13.0
importlib-resources           5.12.0
iniconfig                     2.0.0
injector                      0.20.1
interpret                     0.3.0
interpret-core                0.3.2
ipykernel                     6.22.0
ipython                       8.12.0
ipython-genutils              0.2.0
ipywidgets                    8.0.4
itsdangerous                  2.1.2
jax                           0.4.4
jaxlib                        0.4.4
jedi                          0.18.2
Jinja2                        3.1.2
joblib                        1.2.0
jqdatasdk                     1.8.11
json5                         0.9.11
jsonpatch                     1.32
jsonpointer                   2.0
jsonschema                    4.17.3
jupyter                       1.0.0
jupyter-bokeh                 3.0.5
jupyter-console               6.6.3
jupyter-dash                  0.4.2
jupyter-resource-usage        0.7.2
jupyter-server                1.24.0
jupyter_client                8.2.0
jupyter_core                  5.3.0
jupyterlab                    3.4.4
jupyterlab-pygments           0.2.2
jupyterlab-widgets            3.0.7
jupyterlab_server             2.22.1
keract                        4.5.1
keras                         2.11.0
keras-nlp                     0.4.1
keras-rl                      0.4.2
keras-tuner                   1.3.5
kiwisolver                    1.4.4
kmapper                       2.0.1
korean-lunar-calendar         0.3.1
kt-legacy                     1.0.5
langcodes                     3.3.0
lark                          1.1.5
lazy_loader                   0.2
lazypredict                   0.2.12
libclang                      16.0.0
lightgbm                      3.3.5
lime                          0.2.0.1
line-profiler                 4.0.2
linear-operator               0.3.0
littleutils                   0.2.2
livelossplot                  0.5.5
llvmlite                      0.38.1
locket                        1.0.0
logical-unification           0.4.5
LunarCalendar                 0.0.9
lxml                          4.9.2
lz4                           4.3.2
Mako                          1.2.4
Markdown                      3.4.3
MarkupSafe                    2.1.2
marshmallow                   3.19.0
matplotlib                    3.7.0
matplotlib-inline             0.1.6
miniful                       0.0.6
miniKanren                    1.0.3
minorminer                    0.2.9
mistune                       2.0.5
mljar-supervised              0.11.5
mlxtend                       0.21.0
mmh3                          2.5.1
modin                         0.18.1
mpi4py                        3.1.4
mplfinance                    0.12.9b7
mpmath                        1.2.1
msgpack                       1.0.4
mthree                        2.4.0
multidict                     6.0.4
multipledispatch              0.6.0
multiprocess                  0.70.14
multitasking                  0.0.11
murmurhash                    1.0.9
mxnet                         1.9.1
nbclassic                     0.5.5
nbclient                      0.7.3
nbconvert                     7.3.1
nbeats-keras                  1.8.0
nbeats-pytorch                1.8.0
nbformat                      5.8.0
nest-asyncio                  1.5.6
networkx                      2.8.8
neural-tangents               0.6.2
neuralprophet                 0.5.0
nfoursid                      1.0.1
nltk                          3.8.1
nose                          1.3.7
notebook                      6.5.4
notebook_shim                 0.2.2
ntlm-auth                     1.5.0
numba                         0.55.1
numerapi                      2.13.2
numexpr                       2.8.4
numpy                         1.21.5
numpydoc                      1.5.0
nvidia-cublas-cu11            11.10.3.66
nvidia-cuda-nvrtc-cu11        11.7.99
nvidia-cuda-runtime-cu11      11.7.99
nvidia-cudnn-cu11             8.5.0.96
nvidia-ml-py                  11.525.112
oauthlib                      3.2.2
openai                        0.26.5
opencensus                    0.11.2
opencensus-context            0.1.3
opencv-python                 4.7.0.72
openpyxl                      3.1.1
opt-einsum                    3.3.0
optuna                        3.1.0
orjson                        3.8.10
ortools                       9.4.1874
osqp                          0.6.2.post9
outdated                      0.2.2
packaging                     23.1
pandas                        1.5.3
pandas-datareader             0.10.0
pandas-flavor                 0.5.0
pandas-market-calendars       4.1.4
pandas-ta                     0.3.14b0
pandocfilters                 1.5.0
panel                         0.14.3
param                         1.13.0
parso                         0.8.3
partd                         1.4.0
pastel                        0.2.1
pathos                        0.3.0
pathy                         0.10.1
patsy                         0.5.3
pbr                           5.11.1
penaltymodel                  1.0.2
PennyLane                     0.29.0
PennyLane-Lightning           0.29.0
PennyLane-qiskit              0.29.0
persim                        0.3.1
pexpect                       4.8.0
pickleshare                   0.7.5
Pillow                        9.5.0
pingouin                      0.5.3
pip                           22.0.4
pkgutil_resolve_name          1.3.10
platformdirs                  3.2.0
plotly                        5.13.1
plotly-resampler              0.8.3.2
plucky                        0.4.3
pluggy                        1.0.0
ply                           3.11
pmdarima                      2.0.2
polars                        0.16.9
pomegranate                   0.14.8
pox                           0.3.2
ppft                          1.7.6.6
pprofile                      2.1.0
ppscore                       1.2.0
preshed                       3.0.8
prometheus-client             0.16.0
prompt-toolkit                3.0.38
property-cached               1.6.4
prophet                       1.1.2
protobuf                      3.19.6
psutil                        5.9.5
psycopg2-binary               2.9.6
ptvsd                         4.3.2
ptyprocess                    0.7.0
PuLP                          2.7.0
pure-eval                     0.2.2
py-cpuinfo                    9.0.0
py-heat                       0.0.6
py-heat-magic                 0.0.2
py-lets-be-rational           1.0.1
py-spy                        0.3.14
py-vollib                     1.0.1
py4j                          0.10.9.7
pyaml                         21.10.1
pyarrow                       11.0.0
pyasn1                        0.4.8
pyasn1-modules                0.2.8
pybind11                      2.10.4
pycares                       4.3.0
pycosat                       0.6.4
pycparser                     2.21
pyct                          0.5.0
pydantic                      1.10.7
pyDeprecate                   0.3.2
pydevd-pycharm                201.8538.36
pydmd                         0.4.0.post2301
pyerfa                        2.0.0.3
pyfolio                       0.9.2
pyfolio-reloaded              0.9.5
pyFUME                        0.2.25
Pygments                      2.15.1
pykalman                      0.9.5
pylev                         1.4.0
pyluach                       2.2.0
pymannkendall                 1.4.3
pymc                          5.0.2
pymdptoolbox                  4.0b3
PyMeeus                       0.5.12
PyMySQL                       1.0.3
pynndescent                   0.5.9
pyod                          1.0.9
Pyomo                         6.5.0
pyOpenSSL                     22.0.0
pyparsing                     3.0.9
pyportfolioopt                1.5.4
pyqubo                        1.3.1
pyrb                          1.0.1
pyro-api                      0.1.2
pyro-ppl                      1.8.4
pyrsistent                    0.19.3
pysimdjson                    5.0.2
PySocks                       1.7.1
pystan                        3.6.0
pytensor                      2.9.1
pytest                        7.3.1
python-dateutil               2.8.2
python-statemachine           1.0.3
pytorch-ignite                0.4.11
pytorch-lightning             1.7.4
pytz                          2023.3
pyvinecopulib                 0.6.2
pyviz-comms                   2.2.1
PyWavelets                    1.4.1
PyYAML                        6.0
pyzmq                         25.0.2
qdldl                         0.1.7
qiskit                        0.41.1
qiskit-aer                    0.11.2
qiskit-ibmq-provider          0.20.1
qiskit-terra                  0.23.2
qpd                           0.4.1
qtconsole                     5.4.2
QtPy                          2.3.1
quadprog                      0.1.11
quantecon                     0.6.0
QuantLib                      1.29
QuantStats                    0.0.59
rauth                         0.7.3
ray                           2.3.0
rectangle-packer              2.0.1
regex                         2023.3.23
requests                      2.28.1
requests-ntlm                 1.1.0
requests-oauthlib             1.3.1
retrying                      1.3.4
retworkx                      0.12.1
rich                          12.4.4
ripser                        0.6.4
Riskfolio-Lib                 4.0.3
riskparityportfolio           0.4
river                         0.14.0
rsa                           4.9
ruamel.yaml                   0.17.21
ruamel.yaml.clib              0.2.6
ruptures                      1.1.7
rustworkx                     0.12.1
SALib                         1.4.7
scikeras                      0.10.0
scikit-image                  0.19.3
scikit-learn                  1.2.1
scikit-learn-extra            0.2.0
scikit-multiflow              0.5.3
scikit-optimize               0.9.0
scikit-plot                   0.3.7
scikit-tda                    1.0.0
scipy                         1.8.0
scs                           3.2.3
sdeint                        0.3.0
seaborn                       0.12.2
semantic-version              2.10.0
Send2Trash                    1.8.0
setuptools                    56.0.0
setuptools-scm                7.1.0
shap                          0.41.0
simpful                       2.10.0
simplejson                    3.19.1
simpy                         4.0.1
six                           1.16.0
sklearn-json                  0.1.0
skope-rules                   1.0.1
sktime                        0.16.1
slicer                        0.0.7
smart-open                    6.3.0
sniffio                       1.3.0
snowballstemmer               2.2.0
sortedcontainers              2.4.0
soupsieve                     2.4.1
spacy                         3.5.0
spacy-legacy                  3.0.12
spacy-loggers                 1.0.4
Sphinx                        6.1.3
sphinxcontrib-applehelp       1.0.4
sphinxcontrib-devhelp         1.0.2
sphinxcontrib-htmlhelp        2.0.1
sphinxcontrib-jsmath          1.0.1
sphinxcontrib-qthelp          1.0.3
sphinxcontrib-serializinghtml 1.1.5
SQLAlchemy                    1.4.47
sqlglot                       11.5.5
srsly                         2.4.6
ssm                           0.0.1
stable-baselines3             1.7.0
stack-data                    0.6.2
statsforecast                 1.5.0
statsmodels                   0.13.5
stellargraph                  1.2.1
stevedore                     5.0.0
stochastic                    0.7.0
stockstats                    0.5.2
stumpy                        1.11.1
symengine                     0.10.0
sympy                         1.11.1
ta                            0.10.2
TA-Lib                        0.4.18
tables                        3.8.0
tabulate                      0.8.10
tadasets                      0.0.4
tbats                         1.1.3
tblib                         1.7.0
tenacity                      8.2.2
tensorboard                   2.11.2
tensorboard-data-server       0.6.1
tensorboard-plugin-wit        1.8.1
tensorboardX                  2.6
tensorflow                    2.11.0
tensorflow-addons             0.19.0
tensorflow-decision-forests   1.2.0
tensorflow-estimator          2.11.0
tensorflow-hub                0.13.0
tensorflow-io-gcs-filesystem  0.32.0
tensorflow-probability        0.19.0
tensorflow-text               2.11.0
tensorly                      0.8.0
tensortrade                   1.0.3
termcolor                     2.2.0
terminado                     0.17.1
tf2jax                        0.3.3
thinc                         8.1.9
threadpoolctl                 3.1.0
thriftpy2                     0.4.16
thundergbm                    0.3.17
tick                          0.7.0.1
tifffile                      2023.4.12
tigramite                     5.1.0.3
tinycss2                      1.2.1
toml                          0.10.2
tomli                         2.0.1
toolz                         0.12.0
torch                         1.13.1
torch-cluster                 1.6.0
torch-geometric               2.2.0
torch-scatter                 2.1.0
torch-sparse                  0.6.16
torch-spline-conv             1.2.1
torchmetrics                  0.9.3
torchvision                   0.14.1
tornado                       6.3
tqdm                          4.64.1
trace-updater                 0.0.9.1
trading-calendars             2.1.1
traitlets                     5.9.0
treeinterpreter               0.2.3
triad                         0.8.6
tsfresh                       0.20.0
tslearn                       0.5.3.2
tweepy                        4.10.0
typeguard                     3.0.2
typer                         0.3.2
typing_extensions             4.5.0
umap-learn                    0.5.3
urllib3                       1.26.14
virtualenv                    20.21.0
wasabi                        1.1.1
wcwidth                       0.2.6
webargs                       8.2.0
webencodings                  0.5.1
websocket-client              1.5.1
websockets                    10.4
Werkzeug                      2.2.3
wheel                         0.37.1
widgetsnbextension            4.0.7
wordcloud                     1.8.2.2
wrapt                         1.14.1
wrds                          3.1.6
wurlitzer                     3.0.3
xarray                        2023.1.0
xarray-einstats               0.5.1
xgboost                       1.7.4
xlrd                          2.0.1
XlsxWriter                    3.1.0
yarl                          1.8.2
yellowbrick                   1.5
yfinance                      0.2.18
zict                          3.0.0
zipp                          3.15.0
zope.event                    4.6
zope.interface                6.0
zstandard                     0.18.0

Hudson & Thames Environment

The Hudson & Thames environment cannot be selected on C# projects.

The Hudson & Thames environment supports the following libraries:

# Name                       Version
absl-py                      1.3.0
analytics-python             1.4.0
ansi2html                    1.8.0
anyio                        3.6.2
appdirs                      1.4.4
arch                         4.16.1
argon2-cffi                  21.3.0
argon2-cffi-bindings         21.2.0
asttokens                    2.2.1
astunparse                   1.6.3
attrs                        22.2.0
Babel                        2.11.0
backcall                     0.2.0
backoff                      1.10.0
beautifulsoup4               4.11.1
bleach                       5.0.1
Brotli                       1.0.9
bs4                          0.0.1
cachetools                   5.2.0
certifi                      2022.12.7
cffi                         1.15.1
charset-normalizer           2.1.1
click                        8.1.3
cloudpickle                  2.2.0
clr-loader                   0.1.6
comm                         0.1.2
cramjam                      2.6.2
cssselect                    1.2.0
cvxpy                        1.2.0
cycler                       0.11.0
Cython                       0.29.28
dash                         1.21.0
dash-bootstrap-components    0.13.1
dash-core-components         1.17.1
dash-cytoscape               0.2.0
dash-html-components         1.1.4
dash-table                   4.12.0
dask                         2022.12.1
debugpy                      1.6.4
decorator                    4.4.2
defusedxml                   0.7.1
distributed                  2022.12.1
ecos                         2.0.12
entrypoints                  0.4
executing                    1.2.0
fake-useragent               1.1.1
fastjsonschema               2.16.2
fastparquet                  0.8.1
Flask                        2.1.3
Flask-Compress               1.13
flatbuffers                  22.12.6
fsspec                       2022.11.0
future                       0.18.2
gast                         0.5.3
getmac                       0.8.3
google-auth                  2.15.0
google-auth-oauthlib         0.4.6
google-pasta                 0.2.0
grpcio                       1.51.1
h5py                         3.7.0
HeapDict                     1.0.1
ht-auth                      0.1.0
idna                         3.4
importlib-metadata           5.2.0
importlib-resources          5.10.1
ipykernel                    6.19.4
ipython                      8.7.0
ipython-genutils             0.2.0
itsdangerous                 2.1.2
jedi                         0.18.2
Jinja2                       3.1.2
joblib                       1.2.0
json5                        0.9.10
jsonschema                   4.17.3
jupyter_client               7.4.8
jupyter_core                 5.1.1
jupyter-dash                 0.4.2
jupyter-server               1.23.4
jupyterlab                   3.4.4
jupyterlab-pygments          0.2.2
jupyterlab_server            2.17.0
keras                        2.8.0
Keras-Preprocessing          1.1.2
kiwisolver                   1.4.4
libclang                     14.0.6
llvmlite                     0.39.1
locket                       1.0.0
lxml                         4.6.2
Markdown                     3.4.1
MarkupSafe                   2.1.1
matplotlib                   3.4.3
matplotlib-inline            0.1.6
matrixprofile                1.1.10
mistune                      2.0.4
mlfinlab                     1.6.0
monotonic                    1.6
mpmath                       1.2.1
msgpack                      1.0.4
multitasking                 0.0.11
nbclassic                    0.4.8
nbclient                     0.7.2
nbconvert                    7.2.7
nbformat                     5.7.1
nest-asyncio                 1.5.6
networkx                     2.5.1
notebook                     6.5.2
notebook_shim                0.2.2
numba                        0.56.4
numpy                        1.20.1
oauthlib                     3.2.2
opt-einsum                   3.3.0
osqp                         0.6.2.post8
packaging                    22.0
pandas                       1.1.5
pandocfilters                1.5.0
parse                        1.19.0
parso                        0.8.3
partd                        1.3.0
patsy                        0.5.3
pexpect                      4.8.0
pickleshare                  0.7.5
Pillow                       9.3.0
pip                          22.0.4
pkgutil_resolve_name         1.3.10
platformdirs                 2.6.1
plotly                       5.11.0
pmdarima                     1.8.5
POT                          0.8.2
prometheus-client            0.15.0
prompt-toolkit               3.0.36
property-cached              1.6.4
protobuf                     3.11.2
psutil                       5.9.4
ptyprocess                   0.7.0
pure-eval                    0.2.2
pyasn1                       0.4.8
pyasn1-modules               0.2.8
pybind11                     2.10.1
pycparser                    2.21
pyee                         8.2.2
Pygments                     2.13.0
pykalman                     0.9.5
pyparsing                    3.0.9
pyppeteer                    1.0.2
pyquery                      2.0.0
pyrsistent                   0.19.2
python-dateutil              2.8.2
pytz                         2022.7
pyvinecopulib                0.5.5
PyYAML                       6.0
pyzmq                        24.0.1
qdldl                        0.1.5.post2
requests                     2.28.1
requests-html                0.10.0
requests-oauthlib            1.3.1
retrying                     1.3.4
rsa                          4.9
scikit-learn                 0.24.2
scipy                        1.9.3
scs                          3.2.0
seaborn                      0.11.1
Send2Trash                   1.8.0
setuptools                   56.0.0
setuptools-scm               7.1.0
six                          1.16.0
sniffio                      1.3.0
sortedcontainers             2.4.0
soupsieve                    2.3.2.post1
stack-data                   0.6.2
statsmodels                  0.13.5
stumpy                       1.11.1
TA-Lib                       0.4.18
tblib                        1.7.0
tenacity                     8.1.0
tensorboard                  2.8.0
tensorboard-data-server      0.6.1
tensorboard-plugin-wit       1.8.1
tensorflow                   2.8.0
tensorflow-io-gcs-filesystem 0.29.0
termcolor                    2.1.1
terminado                    0.17.1
tf-estimator-nightly         2.8.0.dev2021122109
threadpoolctl                3.1.0
tinycss2                     1.2.1
tomli                        2.0.1
toolz                        0.12.0
tornado                      6.2
tqdm                         4.64.1
traitlets                    5.8.0
tsfresh                      0.19.0
typing_extensions            4.4.0
urllib3                      1.26.13
w3lib                        2.1.1
wcwidth                      0.2.5
webencodings                 0.5.1
websocket-client             1.4.2
websockets                   10.4
Werkzeug                     2.0.0
wheel                        0.38.4
wrapt                        1.14.1
yahoo-fin                    0.8.6
yfinance                     0.1.63
zict                         2.2.0
zipp                         3.11.0    

Add New Libraries

To request a new library, contact us . We will add the library to the queue for review and deployment. Since the libraries run on our servers, we need to ensure they are secure and won't cause harm. The process of adding new libraries takes 2-4 weeks to complete. View the list of libraries currently under review on the Issues list of the Lean GitHub repository .

Project Libraries

Project libraries are QuantConnect projects you can merge into your project to avoid duplicating code files. If you have tools that you use across several projects, create a library.

Introduction

This page defines terms in QuantConnect products and documentation.

alpha

The quantity of an algorithm's returns that aren't explained by its underlying benchmark.

annual standard deviation

A staticial measure that describes the dispersion of annual returns relative to the mean annual return. It's the square root of the annual variance.

annual variance

A staticial measure that describes the dispersion of annual returns relative to the mean annual return.

average loss

The average rate of return for unprofitable trades.

average win

The average rate of return for profitable trades.

beta

The scale and direction of an algorithm's returns relative to movements in the underlying benchmark.

capacity

The maximum amount of money an algorithm can trade before its performance degrades from market impact.

compounding annual return

The annual percentage return that would be required to grow a portfolio from its starting value to its ending value.

day trade

Buying and selling the same asset within one trading day.

drawdown

The largest peak to trough decline in an algorithm's equity curve.

equity

The total portfolio value if all of the holdings were sold at current market rates.

expectancy

The expected return per trade.

holdings

The absolute sum of the items in the portfolio.

information ratio

The amount of excess return from the risk-free rate per unit of systematic risk.

look-ahead bias

The practice of making decisions using information that would not be available until some time in the future.

loss rate

The proportion of trades that were not profitable.

lowest capacity asset

The asset an algorithm traded that has the lowest capacity.

net profit

(Percent) The rate of return across the entire trading period.

(Dollar-value) The dollar-value return across the entire trading period.

pattern day trader

A trader who executes four or more day trades in the US Equity market within five business days.

Probabilistic Sharpe ratio

The probability that the estimated Sharpe ratio of an algorithm is greater than a benchmark (1).

profit-loss ratio

The ratio of the average win rate to the average loss rate.

return

The rate of return across the entire trading period.

Sharpe ratio

A measure of the risk-adjusted return, developed by William Sharpe.

total fees

The total quantity of fees paid for all the transactions.

total net profit

The rate of return across the entire trading period.

total trades

The number of orders that were filled or partially filled.

tracking error

A measure of how closely a portfolio follows the index to which it is benchmarked. A tracking error of 0 is a perfect match.

Treynor ratio

A measurement of the returns earned in an algorithm in excess of the risk-free rate per unit of benchmark risk, developed by Jack Treynor.

unrealized

The amount of profit a portfolio would capture if it liquidated all open positions and paid the fees for transacting and crossing the spread.

volume

The total value of assets traded for all of an algorithm's transactions.

win rate

The proportion of trades that were profitable after transaction fees.

Introduction

The Initialize method is the entry point of your algorithm where you define a series of settings, including security subscriptions, starting cash balances, and warm-up periods. LEAN only calls the Initialize method one time, at the start of your algorithm.

Set Dates

To set the date range of backtests, call the SetStartDate and SetEndDate methods. The dates you provide are based in the algorithm time zone. By default, the end date is yesterday, one millisecond before midnight. In live trading, LEAN ignores the start and end dates.

SetStartDate(2013, 1, 5);                  // Set start date to January 5, 2013
SetEndDate(2015, 1, 5);                    // Set end date to January 5, 2015
SetEndDate(DateTime.Now.Date.AddDays(-7)); // Set end date to last week

self.SetStartDate(2013, 1, 5)                  # Set start date to January 5, 2013
self.SetEndDate(2015, 1, 5)                    # Set end date to January 5, 2015
self.SetEndDate(datetime.now() - timedelta(7)) # Set end date to last week

Set Account Currency

The algorithm equity curve, benchmark, and performance statistics are denominated in the account currency. To set the account currency, call the SetAccountCurrency method. By default, the account currency is USD. If you call the SetAccountCurrency method, you must call it before you call the SetCash method.

SetAccountCurrency("BTC"); // Set account currency to Bitcoin
SetAccountCurrency("INR"); // Set account currency to Indian Rupees

self.SetAccountCurrency("BTC") # Set account currency to Bitcoin
self.SetAccountCurrency("INR") # Set account currency to Indian Rupees

Set Cash

To set your starting cash in backtests, call the SetCash method. By default, your starting cash is $100,000 USD. In live trading, LEAN ignores the SetCash method and uses the cash balances in your brokerage account instead.

SetCash(100000);       // Set the quantity of the account currency to 100,000
SetCash("BTC", 10);    // Set the Bitcoin quantity to 10
SetCash("EUR", 10000); // Set the EUR quantity to 10,000

self.SetCash(100000)       # Set the quantity of the account currency to 100,000
self.SetCash("BTC", 10)    # Set the Bitcoin quantity to 10
self.SetCash("EUR", 10000) # Set the EUR quantity to 10,000

Set Brokerage and Cash Model

We model your algorithm with margin modeling by default, but you can select a cash account type. Cash accounts don't allow leveraged trading, whereas Margin accounts can support leverage on your account value. To set your brokerage and account type, call the SetBrokerageModel method. For more information about each brokerage and the account types they support, see the brokerage integration documentation. For more information about the reality models that the brokerage models set, see Supported Models .

SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage, AccountType.Margin);

self.SetBrokerageModel(BrokerageName.InteractiveBrokersBrokerage, AccountType.Cash)

The AccountType enumeration has the following members:

Set Universe Settings

The universe settings of your algorithm configure some properties of the universe constituents. The following table describes the properties of the UniverseSettings object:

To set the UniverseSettings , update the preceding properties in the Initialize method before you add the "universe" These settings are globals, so they apply to all universes you create.

// Request second resolution data. This will be slow!
UniverseSettings.Resolution = Resolution.Second;
AddUniverse(MyCoarseFilterFunction);

# Request second resolution data. This will be slow!
self.UniverseSettings.Resolution = Resolution.Second
self.AddUniverse(self.MyCoarseFilterFunction)

Set Security Initializer

Instead of configuring global universe settings, you can individually configure the settings of each security in the universe with a security initializer. Security initializers let you apply any security-level reality model or special data requests on a per-security basis. To set the security initializer, in the Initialize method, call the SetSecurityInitializer method and then define the security initializer.

//In Initialize
SetSecurityInitializer(CustomSecurityInitializer);

private void CustomSecurityInitializer(Security security)
{
    // Disable trading fees
    security.SetFeeModel(new ConstantFeeModel(0, "USD"));
}

#In Initialize
self.SetSecurityInitializer(self.CustomSecurityInitializer)

def CustomSecurityInitializer(self, security: Security) -> None:
    # Disable trading fees
    security.SetFeeModel(ConstantFeeModel(0, "USD"))

For simple requests, you can use the functional implementation of the security initializer. This style lets you configure the security object with one line of code.

SetSecurityInitializer(security => security.SetFeeModel(new ConstantFeeModel(0, "USD")));

self.SetSecurityInitializer(lambda security: security.SetFeeModel(ConstantFeeModel(0, "USD")))

In some cases, you may want to trade a security in the same time loop that you create the security subscription. To avoid errors, use a security initializer to set the market price of each security to the last known price. The GetLastKnownPrices method seeds the security price by gathering the security data over the last 3 days. If there is no data during this period, the security price remains at 0.

var seeder = new FuncSecuritySeeder(GetLastKnownPrices);
SetSecurityInitializer(security => seeder.SeedSecurity(security));

seeder = FuncSecuritySeeder(self.GetLastKnownPrices)
self.SetSecurityInitializer(lambda security: seeder.SeedSecurity(security))

If you call the SetSecurityInitializer method, it overwrites the default security initializer. The default security initializer uses the security-level reality models of the brokerage model to set the following reality models of each security:

• Fill
• Slippage
• Fee
• Buying Power
• Settlement
• Margin Interest Rate

The default security initializer also sets the leverage of each security and intializes each security with a seeder function. To extend upon the default security initializer instead of overwriting it, create a custom BrokerageModelSecurityInitializer .

// In Initialize
SetSecurityInitializer(new MySecurityInitializer(BrokerageModel, new FuncSecuritySeeder(GetLastKnownPrices)));

// Outside of the algorithm class
class MySecurityInitializer : BrokerageModelSecurityInitializer
{
    public MySecurityInitializer(IBrokerageModel brokerageModel, ISecuritySeeder securitySeeder)
        : base(brokerageModel, securitySeeder) {}    
    
    public override void Initialize(Security security)
    {
        // First, call the superclass definition
        // This method sets the reality models of each security using the default reality models of the brokerage model
        base.Initialize(security);

        // Next, overwrite some of the reality models        
        security.SetFeeModel(new ConstantFeeModel(0, "USD"));    
    }
}

# In Initialize
self.SetSecurityInitializer(MySecurityInitializer(self.BrokerageModel, FuncSecuritySeeder(self.GetLastKnownPrices)))

# Outside of the algorithm class
class MySecurityInitializer(BrokerageModelSecurityInitializer):

    def __init__(self, brokerage_model: IBrokerageModel, security_seeder: ISecuritySeeder) -> None:
        super().__init__(brokerage_model, security_seeder)

    def Initialize(self, security: Security) -> None:
        # First, call the superclass definition
        # This method sets the reality models of each security using the default reality models of the brokerage model
        super().Initialize(security)

        # Next, overwrite some of the reality models        
        security.SetFeeModel(ConstantFeeModel(0, "USD"))

To set a seeder function without overwriting the reality models of the brokerage, use the standard BrokerageModelSecurityInitializer .

SetSecurityInitializer(new BrokerageModelSecurityInitializer(BrokerageModel, new FuncSecuritySeeder(GetLastKnownPrices)));

self.SetSecurityInitializer(BrokerageModelSecurityInitializer(self.BrokerageModel, FuncSecuritySeeder(self.GetLastKnownPrices)))

Add Data

You can subscribe to asset, fundamental, alternative, and custom data. The Dataset Market provides 400TB of data that you can easily import into your algorithms.

Asset Data

To subscribe to asset data, call one of the asset subscription methods like AddEquity or AddForex . Each asset class has its own method to create subscriptions. For more information about how to create subscriptions for each asset class, see Asset Classes .

AddEquity("AAPL"); // Add Apple 1 minute bars (minute by default)
AddForex("EURUSD", Resolution.Second); // Add EURUSD 1 second bars

self.AddEquity("SPY")  # Add Apple 1 minute bars (minute by default)
self.AddForex("EURUSD", Resolution.Second) # Add EURUSD 1 second bars

In live trading, you define the securities you want, but LEAN also gets the securities in your live portfolio and sets their resolution to the lowest resolution of the subscriptions you made. For example, if you create subscriptions in your algorithm for securities with Second, Minute, and Hour resolutions, the assets in your live portfolio are given a resolution of Second.

Alternative Data

To add alternative datasets to your algorithms, call the AddData method. For full examples, in the Datasets chapter, select a dataset and see the Requesting Data section.

Custom Data

To add custom data to your algorithms, call the AddData method. For more information about custom data, see Importing Data .

Limitations

There is no official limit to how much data you can add to your algorithms, but there are practical resource limitations. Each security subscription requires about 5MB of RAM, so larger machines let you run algorithms with bigger universes. For more information about our cloud nodes, see Resources .

Set Indicators and Consolidators

You can create and warm-up indicators in the Initialize method.

private Symbol _symbol;
private SimpleMovingAverage _sma;

_symbol = AddEquity("SPY").Symbol;
_sma = SMA(_symbol, 20);
WarmUpIndicator(_symbol, _sma);

self.symbol = self.AddEquity("SPY").Symbol
self.sma = self.SMA(self.symbol, 20)
self.WarmUpIndicator(self.symbol, self.sma)

Set Algorithm Settings

The following table describes the AlgorithmSettings properties:

To change the AlgorithmSettings , update some of the preceding properties.

Settings.RebalancePortfolioOnSecurityChanges = false;

self.Settings.RebalancePortfolioOnSecurityChanges = False

To successfully update the FreePortfolioValue , you must update it after the Initialize method.

Set Benchmark

The benchmark performance is input to calculate several statistics on your algorithm, including alpha and beta . To set a benchmark for your algorithm, call the SetBenchmark method. You can set the benchmark to a security, a constant value, or a value from a custom data source . If you don't set a brokerage model , the default benchmark is SPY. If you set a brokerage model, the model defines the default benchmark.

// Set the benchmark to IBM
SetBenchmark("IBM");

// Set the benchmark to a constant value of 0
SetBenchmark(x => 0);

// Set the benchmark to a value from a custom data source
var symbol = AddData<CustomData>("CustomData", Resolution.Hour).Symbol;
SetBenchmark(symbol);

# Set the benchmark to IBM
self.SetBenchmark("IBM")

# Set the benchmark to a constant value of 0
self.SetBenchmark(lambda x: 0)

# Set the benchmark to a value from a custom data source
self.symbol = self.AddData(CustomData, "CustomData", Resolution.Hour).Symbol
self.SetBenchmark(self.symbol)

If you pass a ticker to the SetBenchmark method, LEAN checks if you have a subscription for it. If you have a subscription for it, LEAN uses the security subscription. If you don't have a subscription for it, LEAN creates a US Equity subscription with the ticker. Since the ticker you pass may not reference a US Equity, we recommend you subscribe to the benchmark security before you call the SetBenchmark method.

Set Time Zone

LEAN supports international trading across multiple time zones and markets, so it needs a reference time zone for the algorithm to set the Time . The default time zone is Eastern Time (ET), which is UTC-4 in summer and UTC-5 in winter. To set a different time zone, call the SetTimeZone method. This method accepts either a string following the IANA Time Zone database convention or a NodaTime .DateTimeZone object. If you pass a string, the method converts it to a NodaTime.DateTimeZone object. The TimeZones class provides the following helper attributes to create NodaTime.DateTimeZone objects:

SetTimeZone("Europe/London");
SetTimeZone(NodaTime.DateTimeZone.Utc);
SetTimeZone(TimeZones.Chicago);

self.SetTimeZone("Europe/London")
self.SetTimeZone(TimeZones.Chicago)

The algorithm time zone may be different from the data time zone . If the time zones are different, it might appear like there is a lag between the algorithm time and the first bar of a history request, but this is just the difference in time zone. All the data is internally synchronized in Coordinated Universal Time (UTC) and arrives in the same Slice object. A slice is a sliver of time with all the data available for this moment.

To keep trades easy to compare between asset classes, we mark all orders in UTC time.

Set Warm Up Period

You may need some historical data at the start of your algorithm to prime technical indicators or populate historical data arrays. The warm-up period pumps data into your algorithm from before the start date. To set a warm-up period, call the SetWarmUp method. The warm-up feature uses the subscriptions you add in Initialize to gather the historical data that warms up the algorithm. If you don't create security subscriptions in the Initialize method, the warm-up won't occur.

// Wind time back 7 days from the start date
SetWarmUp(TimeSpan.FromDays(7));

// Feed in 100 trading days worth of data before the start date
SetWarmUp(100, Resolution.Daily);

// If you don't provide a resolution argument, it uses the lowest resolution in your subscriptions
SetWarmUp(100);

# Wind time back 7 days from the start date
self.SetWarmUp(timedelta(7))

# Feed in 100 trading days worth of data before the start date
self.SetWarmUp(100, Resolution.Daily)

# If you don't provide a resolution argument, it uses the lowest resolution in your subscriptions
self.SetWarmUp(100)

Post Initialization

After the Initialize method, the PostInitialize method performs post-initialization routines, so don't override it. To be notified when the algorithm is ready to begin trading, define an OnWarmupFinished method. This method executes even if you don't set a warm-up period.

public override void OnWarmupFinished()
{
    Log("Algorithm Ready");
}

def OnWarmupFinished(self) -> None:
    self.Log("Algorithm Ready")

Examples

Introduction

A security is an individual financial asset that you might trade on an exchange. LEAN models these unique assets with a Security object, which the AddEquity , AddCrypto , and similar methods return. The Securities property of the QCAlgorithm class is a dictionary where the keys are Symbol objects and the values are Security objects. The Securities dictionary contains all of the securities that have been in the algorithm during its lifetime.

Quote Currency

The quote currency is the currency you must give the seller to buy an asset. For currency trades, the quote currency is the currency ticker on the right side of the currency pair. For other types of assets, the quote currency is usually USD, but the quote currency for India Equities is INR. To get the quote currency of a Security , use the QuoteCurrency property.

var aaplQuoteCurrency = Securities["AAPL"].QuoteCurrency; // USD
var btcusdtQuoteCurrency = Securities["BTCUSDT"].QuoteCurrency; // USDT

aapl_quote_currency = self.Securities["AAPL"].QuoteCurrency # USD
btcusdt_quote_currency = self.Securities["BTCUSDT"].QuoteCurrency # USDT

The QuoteCurrency is a Cash object, which have the following properties:

You can use the ConversionRate property to calculate the value of the minimum price movement in the account currency

var cfd = Securities["SG30SGD"];
var quoteCurrency = cfd.QuoteCurrency; // SGD
var contractMutiplier = cfd.SymbolProperties.ContractMultiplier;
var minimumPriceVariation = cfd.SymbolProperties.MinimumPriceVariation;

// Value of a pip in account currency
var pip = minimumPriceVariation * contractMutiplier * quoteCurrency.ConversionRate;

cfd = self.Securities["SG30SGD"]
quote_currency = cfd.QuoteCurrency # SGD
contract_mutiplier = cfd.SymbolProperties.ContractMultiplier
minimum_price_variation = cfd.SymbolProperties.MinimumPriceVariation

# Value of a pip in account currency
pip = minimum_price_variation * contract_mutiplier * quote_currency.ConversionRate

Security Listing

The Exchange property of a Security object contains information about the exchange that lists the security.

var exchange = Securities["SPY"].Exchange;

exchange = self.Securities["SPY"].Exchange

Security Market

The Market enumeration has the following members:

LEAN groups all of the US Equity exchanges under Market.USA . In live mode, the brokerage routes the orders to the exchange that provides the best price.

Active Securities

The ActiveSecurities property of the algorithm class contains all of the assets currently in your universe. It is a dictionary where the key is a Symbol and the value is a Security . When you remove an asset from a universe, LEAN usually removes the security from the ActiveSecurities collection and removes the security subscription. However, it won't remove the security in any of the following situations:

• You own the security.
• You have an open order for the security.
• The security wasn't in the universe long enough to meet the MinimumTimeInUniverse setting.

When LEAN removes the security, the Security object remains in the Securities collection for record-keeping purposes, like tracking fees and trading volume.

Tradable Status

The IsTradable property shows whether you can trade a security. The property value is true when the security is in the universe, even if the data starts at a later day. Indices, canonical Option securities, and continuous Futures contracts are not tradable. In live mode, custom data objects are also not tradable, even if the custom data represents a tradable asset.

var tradable = Securities["SPY"].IsTradable;

tradable = self.Securities["SPY"].IsTradable

Linked Custom Data

Linked custom data is custom data that's linked to individual assets. In contrast, unlinked data is not linked to specific assets. An example of an unlinked dataset is the US Regulatory Alerts dataset. LEAN passes custom data objects to the OnData method. For more information about custom data, see Custom Securities .

Security Types

LEAN uses the SecurityType enumeration as a synonym for asset classes. The SecurityType enumeration has the following members:

The Base type is for non-financial assets like custom and alternative data objects.

Introduction

Security objects contain the models and properties of an asset.

Security Properties

Security objects have the following properties:

Reality Models

Security objects contain references to the security level reality models . To customize the behavior of each security, configure its reality models.

Symbol Properties

The SymbolProperties property of a Security contains properties for a specific security. SymbolProperties objects have the following properties:

To create a SymbolProperties object, call the constructor.

var symbolProperties = new SymbolProperties(description, quoteCurrency, contractMultiplier, minimumPriceVariation, lotSize, marketTicker);

symbol_properties = SymbolProperties(description, quoteCurrency, contractMultiplier, minimumPriceVariation, lotSize, marketTicker)

The following table describes the arguments of the SymbolProperties constructor:

Introduction

The Exchange property of a Security object contains information about the exchange that lists the security.

Properties

The Exchange property of a Security object returns an SecurityExchange object, which has the following attributes:

Hours

To get the exchange hours, use the Exchange.Hours property on a Security object.

var securityExchangeHours = Securities["SPY"].Exchange.Hours;

security_exchange_hours = self.Securities["SPY"].Exchange.Hours

The preceding code snippet returns a SecurityExchangeHours object, which has the following attributes:

To check if the exchange is open at a specific time, call the IsOpen method.

// Check if the exchange is open at a specific time
var isOpenNow = securityExchangeHours.IsOpen(Time, extendedMarketHours: false);

// Check if the exchange is open at any point in time over a specific interval
var isOpen = securityExchangeHours.IsOpen(Time, Time.AddDays(1), extendedMarketHours: false);

# Check if the exchange is open at a specific time
is_open_now = security_exchange_hours.IsOpen(self.Time, extendedMarketHours=False)

# Check if the exchange is open at any point in time over a specific interval
is_open = security_exchange_hours.IsOpen(self.Time, self.Time + timedelta(days=1), extendedMarketHours=False)

To check if the exchange is open on a specific date, call the IsDateOpen method.

var isOpen = securityExchangeHours.IsDateOpen(Time);

is_open = security_exchange_hours.IsDateOpen(self.Time)

To get the next market open time, call the GetNextMarketOpen method.

var marketOpenTime = securityExchangeHours.GetNextMarketOpen(Time, extendedMarketHours: false);

market_open_time = security_exchange_hours.GetNextMarketOpen(self.Time, extendedMarketHours=False)

To get the next market close time, call the GetNextMarketClose method.

var marketCloseTime = securityExchangeHours.GetNextMarketClose(Time, extendedMarketHours: false);

market_close_time = security_exchange_hours.GetNextMarketClose(self.Time, extendedMarketHours=False)

To get the previous trading day, call the GetPreviousTradingDay method.

var day = securityExchangeHours.GetPreviousTradingDay(Time);

day = security_exchange_hours.GetPreviousTradingDay(self.Time)

To get the next trading day, call the GetNextTradingDay method.

var day = securityExchangeHours.GetNextTradingDay(Time);

day = security_exchange_hours.GetNextTradingDay(self.Time)

Extended Market Hours

By default, your security subscriptions only cover regular trading hours. To subscribe to pre and post-market trading hours for a specific asset, enable the extendedMarketHours argument when you create the security subscription.

AddEquity("SPY", extendedMarketHours: true);

self.AddEquity("SPY", extendedMarketHours=True)

You only receive extended market hours data if you create the subscription with minute, second, or tick resolution. If you create the subscription with daily or hourly resolution, the bars only reflect the regular trading hours.

24 Hour Markets

The Crypto market trades 24/7, but other asset classes only trade during part of the week. Each market has an official trading schedule, but it can be impacted by daylight savings, holidays, and trading halts.

Introduction

If you create a data subscription, your algorithm receives data updates for that security or custom data source.

Characteristics

We thoroughly vet datasets before we add them to the Data Market. The datasets in the Data Market are well-defined with robust ticker and Symbol links to ensure tickers are properly tracked through time. The datasets are consistently delivered on time and most of them are ready for live trading. All the datasets have at least one year of historical data and are free of survivorship bias.

Resolutions

Resolution is the duration of time that's used to sample a data source. The Resolution enumeration has the following members:

The default resolution for market data is Minute . To set the resolution for a security, pass the resolution argument when you create the security subscription.

AddEquity("SPY", Resolution.Daily);

self.AddEquity("SPY", Resolution.Daily)

To set the resolution for all securities, set the Resolution universe setting before you create security subscriptions.

UniverseSettings.Resolution = Resolution.Daily;

self.UniverseSettings.Resolution = Resolution.Daily

To see which resolutions of data are available for a dataset, see the dataset listing in the Data Market . To create custom resolution periods, see Consolidating Data .

Data density describes the frequency of entries in a dataset. Datasets at the tick resolution have dense data density. All other resolutions usually have regular data density. If a non-tick resolution dataset doesn't have an entry at each sampling, it has sparse density.

Fill Forward

Fill forward means if there is no data point for the current slice , LEAN uses the previous data point. Fill forward is the default data setting. If you disable fill forward, you may get stale fills or you may see trade volume as zero.

To disable fill forward for a security, set the fillForward argument to false when you create the security subscription.

AddEquity("SPY", fillForward: false);

self.AddEquity("SPY", fillForward=False)

Extended Market Hours

By default, your security subscriptions only cover regular trading hours. To subscribe to pre and post-market trading hours for a specific asset, enable the extendedMarketHours argument when you create the security subscription.

AddEquity("SPY", extendedMarketHours: true);

self.AddEquity("SPY", extendedMarketHours=True)

You only receive extended market hours data if you create the subscription with minute, second, or tick resolution. If you create the subscription with daily or hourly resolution, the bars only reflect the regular trading hours.

Remove Subscriptions

To remove a security subscription, call the RemoveSecurity method.

RemoveSecurity(_symbol);

self.RemoveSecurity(self.symbol)

The RemoveSecurity method cancels your open orders for the security and liquidates your holdings.

Markets

The datasets integrated into the Dataset Market cover many markets. The Market enumeration has the following members:

LEAN can usually determine the correct market based on the ticker you provide when you create the security subscription. To manually set the market for a security, pass a market argument when you create the security subscription.

AddEquity("SPY", market: Market.USA);

self.AddEquity("SPY", market=Market.USA)

Quotas

There is no limit to the number of security subscriptions you can create, but some live data providers impose data subscription limits. To set a limit, in the Initialize method, set the DataSubscriptionLimit algorithm setting .

Settings.DataSubscriptionLimit = 500;

self.Settings.DataSubscriptionLimit = 500

All securities that you add to the algorithm count as one subscription, except Options and Futures. Every Option and Future contract counts as one subscription.

Introduction

LEAN packages the data for your subscriptions in a Slice object and passes it to the OnData method of your algorithm. To avoid look-ahead bias , LEAN only provides the data that's available at the current time in your algorithm. This processing style ensures that your algorithm backtests in the same manner that it trades live. Your algorithm uses the data to make trading decisions and LEAN uses the data to update your positions, track your portfolio value, and simulate orders.

Security Cache

To get the most recent data for a security, call the GetLastData method on the Security object.

var data = Securities["SPY"].GetLastData();

data = self.Securities["SPY"].GetLastData()

Timeslice

The Slice that LEAN passes to the OnData method represents all of the data for your subscriptions at a single point in time. The Slice object contains data like Tick objects, TradeBar objects, QuoteBar objects, corporate actions , and chains for Option and Future contracts. You can use the data in the Slice to make trading decisions.

To access data in the Slice , index it with the security Symbol . If you use the security ticker instead of the Symbol , LEAN automatically finds the Symbol .

public override void OnData(Slice slice)
{
    if (slice.ContainsKey(_symbol))
    {
        var myData = slice[_symbol];
    }
}

def OnData(self, slice: Slice) -> None:
    if slice.ContainsKey(self.symbol):
        my_data = slice[self.symbol]

The following table shows the Slice property to index based on the data format you want:

public override void OnData(Slice slice)
{
    if (slice.ContainsKey(_symbol))
    {
        var bar = slice.Bars[_symbol];
    }
}

def OnData(self, slice: Slice) -> None:
    if slice.ContainsKey(self.symbol):
        bar = slice.Bars[self.symbol]

If you just index the Slice instead of the preceding properties, it returns the correct object. If your data subscription provides QuoteBar objects and you index the Slice with the security Symbol , it returns the QuoteBar .

Slice objects have the following properties:

For more information about the Slice class, see Timeslices .

Introduction

Unfiltered raw data can be faulty for a number of reasons, including invalid data entry. Moreover, high-frequency traders can deploy bait-and-switch strategies by submitting bait orders to deceive other market participants, making raw data noisy and untradeable. To avoid messing up with our trading logic and model training, you can filter out suspicious raw data with a data filter.

Set Models

To set a data filter for a security, call the SetDataFilter property on the Security object.

// In Initialize
var spy = AddEquity("SPY");
spy.SetDataFilter(new SecurityDataFilter());

# In Initialize
spy = AddEquity("SPY")
spy.SetDataFilter(SecurityDataFilter())

You can also set the data filter model in a security initializer . If your algorithm has a universe, use the security initializer technique. In order to initialize single security subscriptions with the security initializer, call SetSecurityInitializer before you create the subscriptions.

// In Initialize
SetSecurityInitializer(new MySecurityInitializer(BrokerageModel, new FuncSecuritySeeder(GetLastKnownPrices)));

// Outside of the algorithm class
class MySecurityInitializer : BrokerageModelSecurityInitializer
{
    public MySecurityInitializer(IBrokerageModel brokerageModel, ISecuritySeeder securitySeeder)
        : base(brokerageModel, securitySeeder) {}    
    
    public override void Initialize(Security security)
    {
        // First, call the superclass definition
        // This method sets the reality models of each security using the default reality models of the brokerage model
        base.Initialize(security);

        // Next, overwrite some of the reality models        
        security.SetDataFilter(new SecurityDataFilter());    
    }
}

# In Initialize
self.SetSecurityInitializer(MySecurityInitializer(self.BrokerageModel, FuncSecuritySeeder(self.GetLastKnownPrices)))

# Outside of the algorithm class
class MySecurityInitializer(BrokerageModelSecurityInitializer):

    def __init__(self, brokerage_model: IBrokerageModel, security_seeder: ISecuritySeeder) -> None:
        super().__init__(brokerage_model, security_seeder)

    def Initialize(self, security: Security) -> None:
        # First, call the superclass definition
        # This method sets the reality models of each security using the default reality models of the brokerage model
        super().Initialize(security)

        # Next, overwrite some of the reality models        
        security.SetDataFilter(SecurityDataFilter())

Default Behavior

The following table shows the default data filter for each security type:

None of the preceding filters filter out any data.

Model Structure

Data filtering models should implement the ISecurityDataFilter interface. Extensions of the ISecurityDataFilter interface must implement the Filter method, which receives Security and BaseData objects and then returns a boolean object that represents if the data point should be filtered out.

Data filtering models must implement a Filter method, which receives Security and BaseData objects and then returns a boolean object that represents if the data point should be filtered out.

public class MyDataFilter : ISecurityDataFilter
{
    public override bool Filter(Security vehicle, BaseData data)
    {
        return true;
    }
}

class MyDataFilter:
    def Filter(self, vehicle: Security, data: BaseData) -> bool:
        return True

Examples

Introduction

Request US Equity data in your algorithm to receive a feed of asset prices in the OnData method. For more information about the specific dataset we use for backtests, see the US Equities dataset listing . To trade US Equities live, you can use our US Equities data feed or one of the brokerage data feeds .

Create Subscriptions

To create an Equity subscription, in the Initialize method, call the AddEquity method. The AddEquity method returns an Equity object, which contains a Symbol . Save a reference to the Symbol so you can use it in OnData to access the security data in the Slice .

_symbol = AddEquity("SPY").Symbol;

self.symbol = self.AddEquity("SPY").Symbol

The AddEquity method creates a subscription for a single Equity asset and adds it to your user-defined universe. To create a dynamic universe of Equities, add an Equity universe or an Equity Universe Selection model .

To view the supported assets in the US Equities dataset, see the Data Explorer .

Resolutions

The following table shows the available resolutions and data formats for Equity subscriptions:

Resolution	TradeBar	QuoteBar	Trade Tick	Quote Tick
Tick
Second
Minute
Hour
Daily

The default resolution for Equity subscriptions is Resolution.Minute . To change the resolution, pass a resolution argument to the AddEquity method.

_symbol = AddEquity("SPY", Resolution.Daily).Symbol;

self.symbol = self.AddEquity("SPY", Resolution.Daily).Symbol

To create custom resolution periods, see Consolidating Data .

Asset Primary Exchange

When a stock like Apple is listed, it’s listed on Nasdaq. The open auction tick on Nasdaq is the price that’s used as the official open of the day. NYSE, BATS, and other exchanges also have opening auctions, but the only official opening price for Apple is the opening auction on the exchange where it was listed.

Supported Markets

LEAN groups all of the US Equity exchanges under Market.USA . In live mode, the brokerage routes the orders to the exchange that provides the best price.

To set the market for a security, pass a market argument to the AddEquity method.

_symbol = AddEquity("SPY", market: Market.USA).Symbol;

self.symbol = self.AddEquity("SPY", market=Market.USA).Symbol

The brokerage models have a default market for each asset class. If you set a brokerage model, you may not need to specify the market to use.

Fill Forward

Fill forward means if there is no data point for the current slice , LEAN uses the previous data point. Fill forward is the default data setting. If you disable fill forward, you may get stale fills or you may see trade volume as zero.

To disable fill forward for a security, set the fillForward argument to false when you create the security subscription.

AddEquity("SPY", fillForward: false);

self.AddEquity("SPY", fillForward=False)

Margin and Leverage

LEAN models buying power and margin calls to ensure your algorithm stays within the margin requirements. In backtests, the default leverage for margin accounts is 2x leverage and leverage is not available for cash accounts. To change the amount of leverage you can use for a security, pass a leverage argument to the AddEquity method.

_symbol = AddEquity("SPY", leverage: 3).Symbol;

self.symbol = self.AddEquity("SPY", leverage=3).Symbol

In live trading, the brokerage determines how much leverage you may use. For more information about the leverage they provide, see Brokerages .

Extended Market Hours

By default, your security subscriptions only cover regular trading hours. To subscribe to pre and post-market trading hours for a specific asset, enable the extendedMarketHours argument when you create the security subscription.

AddEquity("SPY", extendedMarketHours: true);

self.AddEquity("SPY", extendedMarketHours=True)

You only receive extended market hours data if you create the subscription with minute, second, or tick resolution. If you create the subscription with daily or hourly resolution, the bars only reflect the regular trading hours.

To view the schedule of regular and extended market hours, see Market Hours .

Data Normalization

The data normalization mode defines how historical data is adjusted for corporate actions . The data normalization mode affects the data that LEAN passes to OnData and the data from history requests . By default, LEAN adjusts US Equity data for splits and dividends to produce a smooth price curve, but the following data normalization modes are available:

We use the entire split and dividend history to adjust historical prices. This process ensures you get the same adjusted prices, regardless of the backtest end date.

To set the data normalization mode for a security, pass a dataNormalizationMode argument to the AddEquity method.

_symbol = AddEquity("SPY", dataNormalizationMode: DataNormalizationMode.Raw).Symbol;

self.symbol = self.AddEquity("SPY", dataNormalizationMode=DataNormalizationMode.Raw).Symbol

Properties

The AddEquity method returns an Equity object, which have the following properties:

Introduction

LEAN passes the data you request to the OnData method so you can make trading decisions. The default OnData method accepts a Slice object, but you can define additional OnData methods that accept different data types. For example, if you define an OnData method that accepts a TradeBar argument, it only receives TradeBar objects. The Slice object that the OnData method receives groups all the data together at a single moment in time. To access the Slice outside of the OnData method, use the CurrentSlice property of your algorithm.

All the data formats use DataDictionary objects to group data by Symbol and provide easy access to information. The plural of the type denotes the collection of objects. For instance, the TradeBars DataDictionary is made up of TradeBar objects. To access individual data points in the dictionary, you can index the dictionary with the security ticker or Symbol , but we recommend you use the Symbol .

Trades

TradeBar objects are price bars that consolidate individual trades from the exchanges. They contain the open, high, low, close, and volume of trading activity over a period of time.

TradeBar objects have the following properties:

To get the TradeBar objects in the Slice , index the Slice or index the Bars property of the Slice with the security Symbol . If the security doesn't actively trade or you are in the same time step as when you added the security subscription, the Slice may not contain data for your Symbol . To avoid issues, check if the Slice contains data for your security before you index the Slice with the security Symbol .

public override void OnData(Slice slice)
{
    if (slice.Bars.ContainsKey(_symbol))
    {
        var tradeBar = slice.Bars[_symbol];
    }
}

public void OnData(TradeBars tradeBars)
{
    if (tradeBars.ContainsKey(_symbol))
    {
        var tradeBar = tradeBars[_symbol];
    }
}

def OnData(self, slice: Slice) -> None:
    if self.symbol in slice.Bars:
        trade_bar = slice.Bars[self.symbol]

You can also iterate through the TradeBars dictionary. The keys of the dictionary are the Symbol objects and the values are the TradeBar objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Bars)
    {
        var symbol = kvp.Key;
        var tradeBar = kvp.Value;
        var closePrice = tradeBar.Close;
    }
}

public void OnData(TradeBars tradeBars)
{
    foreach (var kvp in tradeBars)
    {
        var symbol = kvp.Key;
        var tradeBar = kvp.Value;
        var closePrice = tradeBar.Close;
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, trade_bar in slice.Bars.items():
        close_price = trade_bar.Close

We adjust the daily open and close price of bars to reflect the official auction prices .

Quotes

QuoteBar objects are bars that consolidate NBBO quotes from the exchanges. They contain the open, high, low, and close prices of the bid and ask. The Open , High , Low , and Close properties of the QuoteBar object are the mean of the respective bid and ask prices. If the bid or ask portion of the QuoteBar has no data, the Open , High , Low , and Close properties of the QuoteBar copy the values of either the Bid or Ask instead of taking their mean.

QuoteBar objects have the following properties:

To get the QuoteBar objects in the Slice , index the QuoteBars property of the Slice with the security Symbol . If the security doesn't actively get quotes or you are in the same time step as when you added the security subscription, the Slice may not contain data for your Symbol . To avoid issues, check if the Slice contains data for your security before you index the Slice with the security Symbol .

public override void OnData(Slice slice)
{
    if (slice.QuoteBars.ContainsKey(_symbol))
    {
        var quoteBar = slice.QuoteBars[_symbol];
    }
}

public void OnData(QuoteBars quoteBars)
{
    if (quoteBars.ContainsKey(_symbol))
    {
        var quoteBar = quoteBars[_symbol];
    }
}

def OnData(self, slice: Slice) -> None:
    if self.symbol in slice.QuoteBars:
        quote_bar = slice.QuoteBars[self.symbol]

You can also iterate through the QuoteBars dictionary. The keys of the dictionary are the Symbol objects and the values are the QuoteBar objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.QuoteBars)
    {
        var symbol = kvp.Key;
        var quoteBar = kvp.Value;
        var askPrice = quoteBar.Ask.Close;
    }
}

public void OnData(QuoteBars quoteBars)
{
    foreach (var kvp in quoteBars)
    {
        var symbol = kvp.Key;
        var quoteBar = kvp.Value;
        var askPrice = quoteBar.Ask.Close;
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, quote_bar in slice.QuoteBars.items():
        ask_price = quote_bar.Ask.Close

QuoteBar objects let LEAN incorporate spread costs into your simulated trade fills to make backtest results more realistic.

Ticks

Tick objects represent a single trade or quote at a moment in time. A trade tick is a record of a transaction for the security. A quote tick is an offer to buy or sell the security at a specific price. Tick objects have the following properties:

Trade ticks have a non-zero value for the Quantity and Price properties, but they have a zero value for the BidPrice , BidSize , AskPrice , and AskSize properties. Quote ticks have non-zero values for BidPrice and BidSize properties or have non-zero values for AskPrice and AskSize properties. To check if a tick is a trade or a quote, use the TickType property.

In backtests, LEAN groups ticks into one millisecond buckets. In live trading, LEAN groups ticks into ~70-millisecond buckets. To get the Tick objects in the Slice , index the Ticks property of the Slice with a Symbol . If the security doesn't actively trade or you are in the same time step as when you added the security subscription, the Slice may not contain data for your Symbol . To avoid issues, check if the Slice contains data for your security before you index the Slice with the security Symbol .

public override void OnData(Slice slice)
{
    if (slice.Ticks.ContainsKey(_symbol))
    {
        var ticks = slice.Ticks[_symbol];
        foreach (var tick in ticks)
        {
            var price = tick.Price;
        }
    }
}

public void OnData(Ticks ticks)
{
    if (ticks.ContainsKey(_symbol))
    {
        foreach (var tick in ticks[_symbol])
        {
            var price = tick.Price;
        }
    }
}

def OnData(self, slice: Slice) -> None:
    if self.symbol in slice.Ticks:
        ticks = slice.Ticks[self.symbol]
        for tick in ticks:
            price = tick.Price

You can also iterate through the Ticks dictionary. The keys of the dictionary are the Symbol objects and the values are the List<Tick> list[Tick] objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Ticks)
    {
        var symbol = kvp.Key;
        var ticks = kvp.Value;
        foreach (var tick in ticks)
        {
            var price = tick.Price;
        }
    }
}

public void OnData(Ticks ticks)
{
    foreach (var kvp in ticks)
    {
        var symbol = kvp.Key;
        foreach (var tick in kvp.Value)
        {
            var price = tick.Price;
        }
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, ticks in slice.Ticks.items():
        for tick in ticks:
            price = tick.Price

Tick data is raw and unfiltered, so it can contain bad ticks that skew your trade results. For example, some ticks come from dark pools, which aren't tradable. We recommend you only use tick data if you understand the risks and are able to perform your own online tick filtering.

If we detect a tick that may be suspicious , we set its Suspicious flag to true.

Other Data Formats

For more information about data formats available for US Equities, see Corporate Actions .

Introduction

US Equity subscriptions provide notifications for splits, dividends, symbol changes, and delistings.

Splits

When a company does a stock split, the number of shares each shareholder owns increases and the price of each share decreases. When a company does a reverse stock split, the number of shares each shareholder owns decreases and the price of each share increases. A company may perform a stock split or a reverse stock split to adjust the price of their stock so that more investors trade it and the liquidity increases.

When a stock split or reverse stock split occurs for an Equity in your algorithm, LEAN sends a Split object to the OnData method. Split objects have the following properties:

You receive Split objects when a split is in the near future and when it occurs. To know if the split occurs in the near future or now, check the Type property.

If you backtest without the Raw data normalization mode , the splits are factored into the price and volume. If you backtest with the Raw data normalization mode or trade live, when a split occurs, LEAN automatically adjusts your positions based on the SplitFactor . If the post-split quantity isn't a valid lot size , LEAN credits the remaining value to your cashbook in your account currency. If you have indicators in your algorithm, reset your indicators when splits occur so that the data in your indicators account for the price adjustments that the splits cause.

To get the Split objects in the Slice , index the Splits property of the Slice with the security Symbol . The Slice may not contain data for your Symbol . To avoid issues, check if the Splits property contains data for your security before you index it with the security Symbol .

public override void OnData(Slice slice)
{
    if (slice.Splits.ContainsKey(_symbol))
    {
        var split = slice.Splits[_symbol];
    }
}

public void OnData(Splits splits)
{
    if (splits.ContainsKey(_symbol))
    {
        var split = splits[_symbol];
    }
}

def OnData(self, slice: Slice) -> None:
    split = slice.Splits.get(self.symbol)
    if split:
        pass

You can also iterate through the Splits dictionary. The keys of the dictionary are the Symbol objects and the values are the Split objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Splits)
    {
        var symbol = kvp.Key;
        var split = kvp.Value;
    }
}

public void OnData(Splits splits)
{
    foreach (var kvp in splits)
    {
        var symbol = kvp.Key;
        var split = kvp.Value;
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, split in slice.Splits.items():
        pass

LEAN stores the data for stock splits in factor files. To view some example factor files, see the LEAN GitHub repository . In backtests, your algorithm receives Split objects at midnight. In live trading, your algorithm receives Split objects when the factor files are ready.

If you hold an Option contract for an underlying Equity when a split occurs, LEAN closes your Option contract position.

If a split event occurred before an order is filled, the unfilled portion of the order will be adjusted automatically, where its quantity will be multiplied by the split factor and the limit/stop price (if any) will be divided by the split factor.

Dividends

A dividend is a payment that a company gives to shareholders to distribute profits. When a dividend payment occurs for an Equity in your algorithm, LEAN sends a Dividend object to the OnData method. Dividend objects have the following properties:

If you backtest with the Adjusted or TotalReturn data normalization mode, the dividends are factored into the price. If you backtest with the other data normalization modes or trade live, when a dividend payment occurs, LEAN automatically adds the payment amount to your cashbook. If you have indicators in your algorithm, reset your indicators when dividend payments occur so that the data in your indicators account for the price adjustments that the dividend causes.

To get the Dividend objects in the Slice , index the Dividends property of the Slice with the security Symbol . The Slice may not contain data for your Symbol . To avoid issues, check if the Dividends property contains data for your security before you index it with the security Symbol .

public override void OnData(Slice slice)
{
    if (slice.Dividends.ContainsKey(_symbol))
    {
        var dividend = slice.Dividends[_symbol];
    }
}

public void OnData(Dividends dividends)
{
    if (dividends.ContainsKey(_symbol))
    {
        var dividend = dividends[_symbol];
    }
}

def OnData(self, slice: Slice) -> None:
    dividend = slice.Dividends.get(self.symbol)
    if dividend:
        pass

You can also iterate through the Dividends dictionary. The keys of the dictionary are the Symbol objects and the values are the Dividend objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Dividends)
    {
        var symbol = kvp.Key;
        var dividend = kvp.Value;
    }
}

public void OnData(Dividends dividends)
{
    foreach (var kvp in dividends)
    {
        var symbol = kvp.Key;
        var dividend = kvp.Value;
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, dividend in slice.Dividends.items():
        pass

For a full example, see the DividendAlgorithm DividendAlgorithm in the LEAN GitHub repository.

Symbol Changes

The benefit of the Symbol class is that it always maps to the same security, regardless of their trading ticker. When a company changes its trading ticker, LEAN sends a SymbolChangedEvent to the OnData method. SymbolChangedEvent objects have the following properties:

To get the SymbolChangedEvent objects in the Slice , index the SymbolChangedEvents property of the Slice with the security Symbol . The Slice may not contain data for your Symbol . To avoid issues, check if the SymbolChangedEvents property contains data for your security before you index it with the security Symbol .

public override void OnData(Slice slice)
{
    if (slice.SymbolChangedEvents.ContainsKey(_symbol))
    {
        var symbolChangedEvent = slice.SymbolChangedEvents[_symbol];
    }
}

public void OnData(SymbolChangedEvents symbolChangedEvents)
{
    if (symbolChangedEvents.ContainsKey(_symbol))
    {
        var symbolChangedEvent = symbolChangedEvents[_symbol];
    }
}

def OnData(self, slice: Slice) -> None:
    symbol_changed_event = slice.SymbolChangedEvents.get(self.symbol)
    if symbol_changed_event:
        pass

You can also iterate through the SymbolChangedEvents dictionary. The keys of the dictionary are the Symbol objects and the values are the SymbolChangedEvent objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.SymbolChangedEvents)
    {
        var symbol = kvp.Key;
        var symbolChangedEvent = kvp.Value;
    }
}

public void OnData(SymbolChangedEvents symbolChangedEvents)
{
    foreach (var kvp in symbolChangedEvents)
    {
        var symbol = kvp.Key;
        var symbolChangedEvent = kvp.Value;
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, symbol_changed_event in slice.SymbolChangedEvents.items():
        pass

If you have an open order for a security when they change their ticker, LEAN cancels your order. To keep your order, in the OnOrderEvent method, get the quantity and Symbol of the cancelled order and submit a new order.

public override void OnOrderEvent(OrderEvent orderEvent)
{
    if (orderEvent.Status == OrderStatus.Canceled)
    {
        var ticket = Transactions.GetOrderTicket(orderEvent.OrderId);
        if (ticket.Tag.Contains("symbol changed event"))
        {
            Transactions.AddOrder(ticket.SubmitRequest);
        }
    } 
}

def OnOrderEvent(self, order_event: OrderEvent) -> None:
    if order_event.Status == OrderStatus.Canceled:
        ticket = self.Transactions.GetOrderTicket(order_event.OrderId)
        if "symbol changed event" in ticket.Tag:
            self.Transactions.AddOrder(ticket.SubmitRequest)

LEAN stores the data for ticker changes in map files. To view some example map files, see the LEAN GitHub repository .

Delistings

When a company is delisting from an exchange, LEAN sends a Delisting object to the OnData method. Delisting objects have the following properties:

You receive Delisting objects when a delisting is in the near future and when it occurs. To know if the delisting occurs in the near future or now, check the Type property.

To get the Delisting objects in the Slice , index the Delistings property of the Slice with the security Symbol . The Slice may not contain data for your Symbol . To avoid issues, check if the Delistings property contains data for your security before you index it with the security Symbol .

public override void OnData(Slice slice)
{
    if (slice.Delistings.ContainsKey(_symbol))
    {
        var delisting = slice.Delistings[_symbol];
    }
}

public void OnData(Delistings delistings)
{
    if (delistings.ContainsKey(_symbol))
    {
        var delisting = delistings[_symbol];
    }
}

def OnData(self, slice: Slice) -> None:
    delisting = slice.Delistings.get(self.symbol)
    if delisting:
        pass

You can also iterate through the Delistings dictionary. The keys of the dictionary are the Symbol objects and the values are the Delisting objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Delistings)
    {
        var symbol = kvp.Key;
        var delisting = kvp.Value;
    }
}

public void OnData(Delistings delistings)
{
    foreach (var kvp in delistings)
    {
        var symbol = kvp.Key;
        var delisting = kvp.Value;
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, delisting in slice.Delistings.items():
        pass

The delist warning occurs on the final trading day of the stock to give you time to gracefully exit out of positions before LEAN automatically liquidates them.

if (delisting.Type == DelistingType.Warning)
{
    // Liquidate with MarketOnOpenOrder on delisting warning
    var quantity = Portfolio[symbol].Quantity;
    if (quantity != 0)
    {
        MarketOnOpenOrder(symbol, -quantity);
    }
}

if delisting.Type == DelistingType.Warning:
    # Liquidate with MarketOnOpenOrder on delisting warning
    quantity = self.Portfolio[symbol].Quantity
    if quantity != 0:
        self.MarketOnOpenOrder(symbol, -quantity)

For a full example, see the DelistingEventsAlgorithm DelistingEventsAlgorithm in the LEAN GitHub repository.

Introduction

Corporate fundamental data contains all the information on the underlying company of an Equity asset and the information in their financial statements. Since corporate data contains information not found in price and alternative data, adding corporate data to your trading strategies provides you with more information so you can make more informed trading decisions. Corporate fundamental data is available through the US Fundamental Data from Morningstar . To get fundamental data into your algorithm, add a fundamental universe .

Properties

To get fundamental data, access the FineFundamental properties in your fine universe selection function or access the Fundamentals property of the Equity objects in your fundamental universe.

var fundamentals = Securities[_symbol].Fundamentals;

fundamentals = self.Securities[self.symbol].Fundamentals

The US Fundamentals dataset provides FineFundamental objects. To filter FineFundamental objects, you can use the MorningstarSectorCode, MorningstarIndustryGroupCode, and MorningstarIndustryCode enumeration values.

FineFundamental Attributes

FineFundamental objects have the following attributes:

MorningstarSectorCode Enumeration

Sectors are large super categories of data. To access the sector of an Equity, use the MorningstarSectorCode property.

filteredFine = fine.Where(x => x.AssetClassification.MorningstarSectorCode == MorningstarSectorCode.Technology);

filtered_fine = [x for x in fine if x.AssetClassification.MorningstarSectorCode == MorningstarSectorCode.Technology]

The MorningstarSectorCode enumeration has the following members:

MorningstarIndustryGroupCode Enumeration

Industry groups are clusters of related industries which tie together. To access the industry group of an Equity, use the MorningstarIndustryGroupCode property.

filteredFine = fine.Where(x => x.AssetClassification.MorningstarIndustryGroupCode == MorningstarIndustryGroupCode.ApplicationSoftware);

filtered_fine = [x for x in fine if x.AssetClassification.MorningstarIndustryGroupCode == MorningstarIndustryGroupCode.ApplicationSoftware]

The MorningstarIndustryGroupCode enumeration has the following members:

MorningstarIndustryCode Enumeration

Industries are the finest level of classification available and are the individual industries according to the Morningstar classification system. To access the industry group of an Equity, use the MorningstarIndustryCode property:

filteredFine = fine.Where(x => x.AssetClassification.MorningstarIndustryCode == MorningstarIndustryCode.SoftwareApplication);

filtered_fine = [x for x in fine if x.AssetClassification.MorningstarIndustryCode == MorningstarIndustryCode.SoftwareApplication]

The MorningstarIndustryCode enumeration has the following members:

Exchange Id Values

Exchange Id is mapped to represent the exchange that lists the Equity. To access the exchange Id of an Equity, use the PrimaryExchangeID property.

filteredFine = fine.Where(x => x.CompanyReference.PrimaryExchangeID == "NAS");

filtered_fine = [x for x in fine if x.CompanyReference.PrimaryExchangeID == "NAS"]

The exchanges are represented by the following string values:

Historical Data

To get historical fundamental data, set a warm-up period and save the fundamental data during the warm-up period. It’s not currently possible to make a history request for fundamental data in an algorithm. Subscribe to GitHub Issue #4890 to track the feature progress.

Data Updates

The US Fundmamental dataset only provides the originally-reported figures. If there was a mistake in reporting a figure, the data value isn't fixed later. In live trading, new fundamental data is available to your algorithms at approximately 6 AM Eastern Time (ET) each day. The majority of the corporate data update occurs once per month, but the financial ratios update daily. If there is no new data for a period of time, the previous data is filled forward.

Introduction

In a regular long position, you buy shares and then sell them later to close the trade. In a short position, you borrow shares, sell them, and then buy the shares back later to close the trade. Short positions let you profit when a security's price decreases while you have the position open, but there are risks involved. For example, you can get a margin call and you may incur borrowing costs.

Holdings Accounting

If you have an open long position, your portfolio has a positive quantity of shares for that security. In contrast, if you have an open short position, your portfolio has a negative quantity of shares for that security.

Borrowing Costs

In live trading, you usually pay a fee to borrow shares that you use to open a short position. Part of the fee goes to the investor that provided you with the opportunity to short with their shares. The borrowing rate is set by your live brokerage. In backtests, LEAN doesn't currently model borrowing costs, but we have an open GitHub Issue to add the functionality. Subscribe to GitHub Issue #4563 to track the feature progress.

Introduction

The US Equities dataset provides price data for backtests and live trading.

Sourcing

The US Equities data feed consolidates market data across all of the exchanges. Over-the-Counter (OTC) trades are excluded. The data feed is powered by the Securities Information Processor (SIP), so it has 100% market coverage. In contrast, free platforms that display data feeds like the Better Alternative Trading System (BATS) only have about 6-7% market coverage .

We provide live splits, dividends, and corporate actions for US companies. We deliver them to your algorithm before the trading day starts.

Bar Building

We aggregate ticks to build bars.

The bar-building process can exclude ticks. If a tick is excluded, its volume is aggregated in the bar but its price is not aggregated in the bar. Ticks are excluded if any of the following statements are true:

• The tick is suspicious.
• The tick is from the FINRA exchange and meets our price and volume thresholds.
• The trade has none of the following included TradeConditionFlags and at least one of the following excluded TradeConditionFlags :

TradeConditionFlags	Status	Description
Regular	Included	A trade made without stated conditions is deemed the regular way for settlement on the third business day following the transaction date.
FormT	Included	Trading in extended hours enables investors to react quickly to events that typically occur outside regular market hours, such as earnings reports. However, liquidity may be constrained during such Form T trading, resulting in wide bid-ask spreads.
Cash	Included	A transaction that requires delivery of securities and payment on the same day the trade takes place.
ExtendedHours	Included	Identifies a trade that was executed outside of regular primary market hours and is reported as an extended hours trade.
NextDay	Included	A transaction that requires the delivery of securities on the first business day following the trade date.
OfficialClose	Included	Indicates the "official" closing value determined by a Market Center. This transaction report will contain the market center generated closing price.
OfficialOpen	Included	Indicates the 'Official' open value as determined by a Market Center. This transaction report will contain the market center generated opening price.
ClosingPrints	Included	The transaction that constituted the trade-through was a single priced closing transaction by the Market Center.
OpeningPrints	Included	The trade that constituted the trade-through was a single priced opening transaction by the Market Center.
IntermarketSweep	Excluded	The transaction that constituted the trade-through was the execution of an order identified as an Intermarket Sweep Order.
TradeThroughExempt	Excluded	Denotes whether or not a trade is exempt (Rule 611).
OddLot	Excluded	Denotes the trade is an odd lot less than a 100 shares.

• The quote has a size of less than 100 shares.
• The quote has one of the following QuoteConditionFlags :

QuoteConditionFlags	Description
Closing	Indicates that this quote was the last quote for a security for that Participant.
NewsDissemination	Denotes a regulatory trading halt when relevant news influencing the security is being disseminated. Trading is suspended until the primary market determines that an adequate publication or disclosure of information has occurred.
NewsPending	Denotes a regulatory Trading Halt due to an expected news announcement, which may influence the security. An Opening Delay or Trading Halt may be continued once the news has been disseminated.
TradingRangeIndication	Denotes the probable trading range (Bid and Offer prices, no sizes) of a security that is not Opening Delayed or Trading Halted. The Trading Range Indication is used prior to or after the opening of a security.
OrderImbalance	Denotes a non-regulatory halt condition where there is a significant imbalance of buy or sell orders.
Resume	Indicates that trading for a Participant is no longer suspended in a security that had been Opening Delayed or Trading Halted.

• The quote has none of the following QuoteConditionFlags :

QuoteConditionFlags	Description
Regular	This condition is used for the majority of quotes to indicate a normal trading environment.
Slow	This condition is used to indicate that the quote is a Slow Quote on both the bid and offer sides due to a Set Slow List that includes high price securities.
Gap	While in this mode, auto-execution is not eligible, the quote is then considered manual and non-firm in the bid and offer, and either or both sides can be traded through as per Regulation NMS.
OpeningQuote	This condition can be disseminated to indicate that this quote was the opening quote for a security for that Participant.
FastTrading	For extremely active periods of short duration. While in this mode, the UTP Participant will enter quotations on a best efforts basis.
Resume	Indicate that trading for a Participant is no longer suspended in a security which had been Opening Delayed or Trading Halted.

In the preceding tables, Participant refers to the entities on page 19 of the Consolidated Tape System Multicast Output Binary Specification .

Suspicious Ticks

Tick price data is raw and unfiltered, so it can contain a lot of noise. If a tick is not tradable, we flag it as suspicious. This process makes the bars a more realistic representation of what you could execute in live trading. If you use tick data, avoid using suspicious ticks in your algorithms as informative data points. We recommend only using tick data if you understand the risks and are able to perform your own tick filtering. Ticks are flagged as suspicious in the following situations:

• The tick occurs below the best bid or above the best ask


This image shows a tick that occurred above the best ask price of a security. The green line represents the best ask of the security, the blue line represents the best bid of the security, and the red dots represent trade ticks. The ticks between the best bid and ask occur from filling hidden orders. The tick that occurred above the best ask price is flagged as suspicious.

• The tick occurs far from the current market price


This image shows a tick that occurred far from the price of the security. The red dots represent trade ticks. The tick that occurred far from the market price is flagged as suspicious.

• The tick occurs on a dark pool
• The tick is rolled back
• The tick is reported late

Market Auction Prices

The opening and closing price of the day is set by very specific opening and closing auction ticks. When a stock like Apple is listed, it’s listed on Nasdaq. The open auction tick on Nasdaq is the price that’s used as the official open of the day. NYSE, BATS, and other exchanges also have opening auctions, but the only official opening price for Apple is the opening auction on the exchange where it was listed.

We set the opening and closing prices of the first and last bars of the day to the official auction prices. This process is used for second, minute, hour, and daily bars for the 9:30 AM and 4:30 PM Eastern Time (ET) prices. In contrast, other platforms might not be using the correct opening and closing prices.

The official auction prices are usually emitted 2-30 seconds after the market open and close. We do our best to use the official opening and closing prices in the bars we build, but the delay can be so large that there isn't enough time to update the opening and closing price of the bar before it's injected into your algorithms. For example, if you subscribe to second resolution data, we wait until the end of the second for the opening price but most second resolution data won’t get the official opening price. If you subscribe to minute resolution data, we wait until the end of the minute for the opening auction price. Most of the time, you’ll get the actual opening auction price with minute resolution data, but there are always exceptions. Nasdaq and NYSE can have delays in publishing the opening auction price, but we don’t have control over those issues and we have to emit the data on time so that you get the bar you are expecting.

Live and Backtesting Differences

In live trading, bars are built using the exchange timestamps with microsecond accuracy. This microsecond-by-microsecond processing of the ticks can mean that the individual bars between live trading and backtesting can have slightly different ticks. As a result, it's possible for a tick to be counted in different bars between backtesting and live trading, which can lead to bars having slightly different open, high, low, close, and volume values.

Data Availability

In live trading, live data is available in real-time. In backtests, live data is available at the following pre-market trading session.

Introduction

This page shows the trading hours, holidays, and time zone of the US Equity market.

Pre-market Hours

The following table shows the pre-market hours for the US Equity market:

Regular Trading Hours

The following table shows the regular trading hours for the US Equity market:

Post-market Hours

The following table shows the post-market hours for the US Equity market:

Holidays

LEAN uses the trading holidays from the NYSE website.

The following table shows the dates of holidays for the US Equity market:

Early Closes

The following table shows the early closes for the US Equity market:

Late Opens

There are no days with late opens.

Time Zone

The US Equity market trades in the America/New York time zone.

Introduction

Request India Equity data in your algorithm to receive a feed of asset prices in the OnData method. For more information about the specific dataset we use for backtests, see the India Equities dataset listing . To trade India Equities live, you can use one of the brokerage data feeds .

Create Subscriptions

To create an India Equity subscription, in the Initialize method, call the AddEquity method. The AddEquity method returns an Equity object, which contains a Symbol . Save a reference to the Symbol so you can use it in OnData to access the security data in the Slice .

_symbol = AddEquity("YESBANK", market: Market.India).Symbol;

self.symbol = self.AddEquity("YESBANK", market=Market.India).Symbol

If you set the brokerage model to an India brokerage, you don't need to pass a market argument. To view the integrated brokerages that offer India Equities, see Brokerages .

To view the supported assets in the India Equities dataset, see the Data Explorer .

Resolutions

The following table shows the available resolutions and data formats for India Equity subscriptions:

Resolution	TradeBar	QuoteBar	Trade Tick	Quote Tick
Tick
Second
Minute
Hour
Daily

The default resolution for India Equity subscriptions is Resolution.Minute . To change the resolution, pass a resolution argument to the AddEquity method.

_symbol = AddEquity("YESBANK", Resolution.Daily, Market.India).Symbol;

self.symbol = self.AddEquity("YESBANK", Resolution.Daily, Market.India).Symbol

To create custom resolution periods, see Consolidating Data .

Supported Markets

LEAN groups all of the India Equity exchanges under Market.India . To set the market for a security, pass a market argument to the AddEquity method.

_symbol = AddEquity("YESBANK", market: Market.India).Symbol;

self.symbol = self.AddEquity("YESBANK", market=Market.India).Symbol

The brokerage models have a default market for each asset class. If you set a brokerage model, you may not need to specify the market to use.

Fill Forward

Fill forward means if there is no data point for the current slice , LEAN uses the previous data point. Fill forward is the default data setting. If you disable fill forward, you may get stale fills or you may see trade volume as zero.

To disable fill forward for a security, set the fillForward argument to false when you create the security subscription.

_symbol = AddEquity("YESBANK", market: Market.India, fillForward: false).Symbol;

self.symbol = self.AddEquity("YESBANK", market=Market.India, fillForward=False).Symbol

Margin and Leverage

LEAN models buying power and margin calls to ensure your algorithm stays within the margin requirements. The amount of margin that's available depends on the brokerage model you use. For more information about the margin requirements of each brokerage, see the Margin section of the brokerage guides . To change the amount of leverage you can use for a security, pass a leverage argument to the AddEquity method.

_symbol = AddEquity("YESBANK", market: Market.India, leverage: 3).Symbol;

self.symbol = self.AddEquity("YESBANK", market=Market.India, leverage=3).Symbol

Extended Market Hours

By default, your security subscriptions only cover regular trading hours. To subscribe to pre and post-market trading hours for a specific asset, enable the extendedMarketHours argument when you create the security subscription.

_symbol = AddEquity("YESBANK", market: Market.India, extendedMarketHours: true).Symbol;

self.symbol = self.AddEquity("YESBANK", market=Market.India, extendedMarketHours=True).Symbol

You only receive extended market hours data if you create the subscription with minute, second, or tick resolution. If you create the subscription with daily or hourly resolution, the bars only reflect the regular trading hours.

To view the schedule of regular and extended market hours, see Market Hours .

Data Normalization

The data normalization mode defines how historical data is adjusted for corporate actions . The data normalization mode affects the data that LEAN passes to OnData and the data from history request . By default, LEAN adjusts India Equity data for splits and dividends to produce a smooth price curve. The following data normalization modes are available:

We use the entire split and dividend history to adjust historical prices. This process ensures you get the same adjusted prices, regardless of the backtest end date.

To set the data normalization mode for a security, pass a dataNormalizationMode argument to the AddEquity method..

_symbol = AddEquity("YESBANK", market: Market.India, dataNormalizationMode: DataNormalizationMode.Raw).Symbol;

self.symbol = AddEquity("YESBANK", market=Market.India, dataNormalizationMode=DataNormalizationMode.Raw).Symbol

Properties

The AddEquity method returns an Equity object, which have the following properties:

Introduction

LEAN passes the data you request to the OnData method so you can make trading decisions. The default OnData method accepts a Slice object, but you can define additional OnData methods that accept different data types. For example, if you define an OnData method that accepts a TradeBar argument, it only receives TradeBar objects. The Slice object that the OnData method receives groups all the data together at a single moment in time. To access the Slice outside of the OnData method, use the CurrentSlice property of your algorithm.

All the data formats use DataDictionary objects to group data by Symbol and provide easy access to information. The plural of the type denotes the collection of objects. For instance, the TradeBars DataDictionary is made up of TradeBar objects. To access individual data points in the dictionary, you can index the dictionary with the security ticker or Symbol , but we recommend you use the Symbol .

Trades

TradeBar objects are price bars that consolidate individual trades from the exchanges. They contain the open, high, low, close, and volume of trading activity over a period of time.

TradeBar objects have the following properties:

To get the TradeBar objects in the Slice , index the Slice or index the Bars property of the Slice with the security Symbol . If the security doesn't actively trade or you are in the same time step as when you added the security subscription, the Slice may not contain data for your Symbol . To avoid issues, check if the Slice contains data for your security before you index the Slice with the security Symbol .

public override void OnData(Slice slice)
{
    if (slice.Bars.ContainsKey(_symbol))
    {
        var tradeBar = slice.Bars[_symbol];
    }
}

public void OnData(TradeBars tradeBars)
{
    if (tradeBars.ContainsKey(_symbol))
    {
        var tradeBar = tradeBars[_symbol];
    }
}

def OnData(self, slice: Slice) -> None:
    if self.symbol in slice.Bars:
        trade_bar = slice.Bars[self.symbol]

You can also iterate through the TradeBars dictionary. The keys of the dictionary are the Symbol objects and the values are the TradeBar objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Bars)
    {
        var symbol = kvp.Key;
        var tradeBar = kvp.Value;
        var closePrice = tradeBar.Close;
    }
}

public void OnData(TradeBars tradeBars)
{
    foreach (var kvp in tradeBars)
    {
        var symbol = kvp.Key;
        var tradeBar = kvp.Value;
        var closePrice = tradeBar.Close;
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, trade_bar in slice.Bars.items():
        close_price = trade_bar.Close

Introduction

India Equity subscriptions provide notifications for splits, dividends, symbol changes, and delistings.

Splits

When a company does a stock split, the number of shares each shareholder owns increases and the price of each share decreases. When a company does a reverse stock split, the number of shares each shareholder owns decreases and the price of each share increases. A company may perform a stock split or a reverse stock split to adjust the price of their stock so that more investors trade it and the liquidity increases.

When a stock split or reverse stock split occurs for an Equity in your algorithm, LEAN sends a Split object to the OnData method. Split objects have the following properties:

You receive Split objects when a split is in the near future and when it occurs. To know if the split occurs in the near future or now, check the Type property.

If you backtest without the Raw data normalization mode , the splits are factored into the price and volume. If you backtest with the Raw data normalization mode or trade live, when a split occurs, LEAN automatically adjusts your positions based on the SplitFactor . If the post-split quantity isn't a valid lot size , LEAN credits the remaining value to your cashbook in your account currency. If you have indicators in your algorithm, reset your indicators when splits occur so that the data in your indicators account for the price adjustments that the splits cause.

To get the Split objects in the Slice , index the Splits property of the Slice with the security Symbol . The Slice may not contain data for your Symbol . To avoid issues, check if the Splits property contains data for your security before you index it with the security Symbol .

public override void OnData(Slice slice)
{
    if (slice.Splits.ContainsKey(_symbol))
    {
        var split = slice.Splits[_symbol];
    }
}

public void OnData(Splits splits)
{
    if (splits.ContainsKey(_symbol))
    {
        var split = splits[_symbol];
    }
}

def OnData(self, slice: Slice) -> None:
    split = slice.Splits.get(self.symbol)
    if split:
        pass

You can also iterate through the Splits dictionary. The keys of the dictionary are the Symbol objects and the values are the Split objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Splits)
    {
        var symbol = kvp.Key;
        var split = kvp.Value;
    }
}

public void OnData(Splits splits)
{
    foreach (var kvp in splits)
    {
        var symbol = kvp.Key;
        var split = kvp.Value;
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, split in slice.Splits.items():
        pass

LEAN stores the data for stock splits in factor files. To view some example factor files, see the LEAN GitHub repository . In backtests, your algorithm receives Split objects at midnight. In live trading, your algorithm receives Split objects when the factor files are ready.

If you hold an Option contract for an underlying Equity when a split occurs, LEAN closes your Option contract position.

If a split event occurred before an order is filled, the unfilled portion of the order will be adjusted automatically, where its quantity will be multiplied by the split factor and the limit/stop price (if any) will be divided by the split factor.

Dividends

A dividend is a payment that a company gives to shareholders to distribute profits. When a dividend payment occurs for an Equity in your algorithm, LEAN sends a Dividend object to the OnData method. Dividend objects have the following properties:

If you backtest with the Adjusted or TotalReturn data normalization mode, the dividends are factored into the price. If you backtest with the other data normalization modes or trade live, when a dividend payment occurs, LEAN automatically adds the payment amount to your cashbook. If you have indicators in your algorithm, reset your indicators when dividend payments occur so that the data in your indicators account for the price adjustments that the dividend causes.

To get the Dividend objects in the Slice , index the Dividends property of the Slice with the security Symbol . The Slice may not contain data for your Symbol . To avoid issues, check if the Dividends property contains data for your security before you index it with the security Symbol .

public override void OnData(Slice slice)
{
    if (slice.Dividends.ContainsKey(_symbol))
    {
        var dividend = slice.Dividends[_symbol];
    }
}

public void OnData(Dividends dividends)
{
    if (dividends.ContainsKey(_symbol))
    {
        var dividend = dividends[_symbol];
    }
}

def OnData(self, slice: Slice) -> None:
    dividend = slice.Dividends.get(self.symbol)
    if dividend:
        pass

You can also iterate through the Dividends dictionary. The keys of the dictionary are the Symbol objects and the values are the Dividend objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Dividends)
    {
        var symbol = kvp.Key;
        var dividend = kvp.Value;
    }
}

public void OnData(Dividends dividends)
{
    foreach (var kvp in dividends)
    {
        var symbol = kvp.Key;
        var dividend = kvp.Value;
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, dividend in slice.Dividends.items():
        pass

For a full example, see the DividendAlgorithm DividendAlgorithm in the LEAN GitHub repository.

Symbol Changes

The benefit of the Symbol class is that it always maps to the same security, regardless of their trading ticker. When a company changes its trading ticker, LEAN sends a SymbolChangedEvent to the OnData method. SymbolChangedEvent objects have the following properties:

To get the SymbolChangedEvent objects in the Slice , index the SymbolChangedEvents property of the Slice with the security Symbol . The Slice may not contain data for your Symbol . To avoid issues, check if the SymbolChangedEvents property contains data for your security before you index it with the security Symbol .

public override void OnData(Slice slice)
{
    if (slice.SymbolChangedEvents.ContainsKey(_symbol))
    {
        var symbolChangedEvent = slice.SymbolChangedEvents[_symbol];
    }
}

public void OnData(SymbolChangedEvents symbolChangedEvents)
{
    if (symbolChangedEvents.ContainsKey(_symbol))
    {
        var symbolChangedEvent = symbolChangedEvents[_symbol];
    }
}

def OnData(self, slice: Slice) -> None:
    symbol_changed_event = slice.SymbolChangedEvents.get(self.symbol)
    if symbol_changed_event:
        pass

You can also iterate through the SymbolChangedEvents dictionary. The keys of the dictionary are the Symbol objects and the values are the SymbolChangedEvent objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.SymbolChangedEvents)
    {
        var symbol = kvp.Key;
        var symbolChangedEvent = kvp.Value;
    }
}

public void OnData(SymbolChangedEvents symbolChangedEvents)
{
    foreach (var kvp in symbolChangedEvents)
    {
        var symbol = kvp.Key;
        var symbolChangedEvent = kvp.Value;
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, symbol_changed_event in slice.SymbolChangedEvents.items():
        pass

If you have an open order for a security when they change their ticker, LEAN cancels your order. To keep your order, in the OnOrderEvent method, get the quantity and Symbol of the cancelled order and submit a new order.

public override void OnOrderEvent(OrderEvent orderEvent)
{
    if (orderEvent.Status == OrderStatus.Canceled)
    {
        var ticket = Transactions.GetOrderTicket(orderEvent.OrderId);
        if (ticket.Tag.Contains("symbol changed event"))
        {
            Transactions.AddOrder(ticket.SubmitRequest);
        }
    } 
}

def OnOrderEvent(self, order_event: OrderEvent) -> None:
    if order_event.Status == OrderStatus.Canceled:
        ticket = self.Transactions.GetOrderTicket(order_event.OrderId)
        if "symbol changed event" in ticket.Tag:
            self.Transactions.AddOrder(ticket.SubmitRequest)

LEAN stores the data for ticker changes in map files. To view some example map files, see the LEAN GitHub repository .

Delistings

When a company is delisting from an exchange, LEAN sends a Delisting object to the OnData method. Delisting objects have the following properties:

You receive Delisting objects when a delisting is in the near future and when it occurs. To know if the delisting occurs in the near future or now, check the Type property.

To get the Delisting objects in the Slice , index the Delistings property of the Slice with the security Symbol . The Slice may not contain data for your Symbol . To avoid issues, check if the Delistings property contains data for your security before you index it with the security Symbol .

public override void OnData(Slice slice)
{
    if (slice.Delistings.ContainsKey(_symbol))
    {
        var delisting = slice.Delistings[_symbol];
    }
}

public void OnData(Delistings delistings)
{
    if (delistings.ContainsKey(_symbol))
    {
        var delisting = delistings[_symbol];
    }
}

def OnData(self, slice: Slice) -> None:
    delisting = slice.Delistings.get(self.symbol)
    if delisting:
        pass

You can also iterate through the Delistings dictionary. The keys of the dictionary are the Symbol objects and the values are the Delisting objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Delistings)
    {
        var symbol = kvp.Key;
        var delisting = kvp.Value;
    }
}

public void OnData(Delistings delistings)
{
    foreach (var kvp in delistings)
    {
        var symbol = kvp.Key;
        var delisting = kvp.Value;
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, delisting in slice.Delistings.items():
        pass

The delist warning occurs on the final trading day of the stock to give you time to gracefully exit out of positions before LEAN automatically liquidates them.

if (delisting.Type == DelistingType.Warning)
{
    // Liquidate with MarketOnOpenOrder on delisting warning
    var quantity = Portfolio[symbol].Quantity;
    if (quantity != 0)
    {
        MarketOnOpenOrder(symbol, -quantity);
    }
}

if delisting.Type == DelistingType.Warning:
    # Liquidate with MarketOnOpenOrder on delisting warning
    quantity = self.Portfolio[symbol].Quantity
    if quantity != 0:
        self.MarketOnOpenOrder(symbol, -quantity)

For a full example, see the DelistingEventsAlgorithm DelistingEventsAlgorithm in the LEAN GitHub repository.

Introduction

The India Equities dataset provides price data for backtests.

Sourcing

TrueData is an authorized NSE and MCX data vendor founded by Kapil Marwaha in 2007, with the goal of providing users with a multitude of solutions for the financial services sector, including making market data feeds available in all its forms, to as many applications as possible, including a wide range of technical analysis applications, trading solutions, automated & algorithmic traders/platforms and a lot more.

Bar Building

We receive minute-resolution trade data and aggregate it to build hour and daily bars. To create custom resolution periods, see Consolidating Data .

Introduction

This page shows the trading hours, holidays, and time zone of the India Equity market.

Pre-market Hours

The following table shows the pre-market hours for the India Equity market:

Regular Trading Hours

The following table shows the regular trading hours for the India Equity market:

Post-market Hours

The following table shows the post-market hours for the India Equity market:

Holidays

The following table shows the dates of holidays for the India Equity market:

Early Closes

There are no days with early closes.

Late Opens

There are no days with late opens.

Time Zone

The India Equity market trades in the Asia/Kolkata time zone.

Introduction

Request Equity Options data in your algorithm to receive a feed of contract prices in the OnData method. For more information about the specific dataset we use for backtests, see the US Equity Options dataset listing . To trade Equity Options live, you can use one of the brokerage data feeds . We currently only support American-style Options for US Equity Options.

Create Subscriptions

Before you can subscribe to an Option contract, you must configure the underlying Equity and get the contract Symbol .

Configure the Underlying Equity

If you want to subscribe to the underlying Equity in the Initialize method, set the Equity data normalization to DataNormalizationMode.Raw .

_symbol = AddEquity("SPY", dataNormalizationMode: DataNormalizationMode.Raw).Symbol;

self.symbol = self.AddEquity("SPY", dataNormalizationMode=DataNormalizationMode.Raw).Symbol

If your algorithm has a dynamic universe of Equities, before you add the Equity universe in the Initialize method, set the universe data normalization mode to DataNormalizationMode.Raw .

UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw;

self.UniverseSettings.DataNormalizationMode = DataNormalizationMode.Raw

To override the initial guess of implied volatility , set and warm up the underlying volatility model .

Get Contract Symbols

To subscribe to an Option contract, you need the contract Symbol . You can get the contract Symbol from the CreateOption method or from the OptionChainProvider . If you use the CreateOption method, you need to provide the details of an existing contract.

_contractSymbol = QuantConnect.Symbol.CreateOption(_symbol, Market.USA,
    OptionStyle.American, OptionRight.Call, 365, new DateTime(2022, 6, 17));

self.contract_symbol = Symbol.CreateOption(self.symbol, Market.USA,
    OptionStyle.American, OptionRight.Call, 365, datetime(2022, 6, 17))

Another way to get an Option contract Symbol is to use the OptionChainProvider . The GetOptionContractList method of OptionChainProvider returns a list of Symbol objects that reference the available Option contracts for a given underlying Equity on a given date. To filter and select contracts, you can use the following properties of each Symbol object:

var contractSymbols = OptionChainProvider.GetOptionContractList(_symbol, Time);
var expiry = contractSymbols.Select(symbol => symbol.ID.Date).Min();
var filteredSymbols = contractSymbols.Where(symbol => symbol.ID.Date == expiry && symbol.ID.OptionRight == OptionRight.Call);
_contractSymbol = filteredSymbols.OrderByDescending(symbol => symbol.ID.StrikePrice).Last();

contract_symbols = self.OptionChainProvider.GetOptionContractList(self.symbol, self.Time)
expiry = min([symbol.ID.Date for symbol in contract_symbols])
filtered_symbols = [symbol for symbol in contract_symbols if symbol.ID.Date == expiry and symbol.ID.OptionRight == OptionRight.Call]
self.contract_symbol = sorted(filtered_symbols, key=lambda symbol: symbol.ID.StrikePrice)[0]

Subscribe to Contracts

To create an Equity Option contract subscription, pass the contract Symbol to the AddOptionContract method. Save a reference to the contract Symbol so you can easily access the Option contract in the OptionChain that LEAN passes to the OnData method. This method returns an Option object. To override the default pricing model of the Option, set a pricing model .

var option = AddOptionContract(_contractSymbol);
option.PriceModel = OptionPriceModels.BjerksundStensland();

option = self.AddOptionContract(self.contract_symbol)
option.PriceModel = OptionPriceModels.BjerksundStensland()

The AddOptionContract method creates a subscription for a single Option contract and adds it to your user-defined universe. To create a dynamic universe of Option contracts, add an Equity Options universe or an Options Universe Selection model .

Warm Up Contract Prices

If you subscribe to an Option contract with AddOptionContract , you'll need to wait until the next Slice to receive data and trade the contract. To trade the contract in the same time step you subscribe to the contract, set the current price of the contract in a security initializer .

var seeder = new FuncSecuritySeeder(GetLastKnownPrices);
SetSecurityInitializer(new BrokerageModelSecurityInitializer(BrokerageModel, seeder, this));

seeder = FuncSecuritySeeder(self.GetLastKnownPrices)
self.SetSecurityInitializer(BrokerageModelSecurityInitializer(self.BrokerageModel, seeder, self))

Supported Assets

To view the supported assets in the US Equities dataset, see the Data Explorer .

Resolutions

The following table shows the available resolutions and data formats for Equity Option contract subscriptions:

Resolution	TradeBar	QuoteBar	Trade Tick	Quote Tick
Tick
Second
Minute
Hour
Daily

The default resolution for Option contract subscriptions is Resolution.Minute . To change the resolution, pass a resolution argument to the AddOptionContract method.

AddOptionContract(_contractSymbol, Resolution.Minute);

self.AddOptionContract(self.contract_symbol, Resolution.Minute)

To create custom resolution periods, see Consolidating Data .

Supported Markets

LEAN groups all of the US Equity exchanges under Market.USA . You don't need to pass a Market argument to the AddOptionContract method because the contract Symbol already contains the market.

Fill Forward

Fill forward means if there is no data point for the current slice , LEAN uses the previous data point. Fill forward is the default data setting. If you disable fill forward, you may get stale fills or you may see trade volume as zero.

To disable fill forward for a security, set the fillForward argument to false when you create the security subscription.

AddOptionContract(_contractSymbol, fillForward: false);

self.AddOptionContract(self.contract_symbol, fillForward=False)

Margin and Leverage

LEAN models buying power and margin calls to ensure your algorithm stays within the margin requirements. Options are already leveraged products, so you can't change their leverage.

Extended Market Hours

By default, your security subscriptions only cover regular trading hours. To subscribe to pre and post-market trading hours for a specific asset, enable the extendedMarketHours argument when you create the security subscription.

AddOptionContract(_contractSymbol, extendedMarketHours: true);

self.AddOptionContract(self.contract_symbol, extendedMarketHours=True)

You only receive extended market hours data if you create the subscription with minute, second, or tick resolution. If you create the subscription with daily or hourly resolution, the bars only reflect the regular trading hours.

To view the schedule of regular and extended market hours, see Market Hours .

Remove Subscriptions

To remove a contract subscription that you created with AddOptionContract , call the RemoveOptionContract method. This method is an alias for RemoveSecurity .

RemoveOptionContract(_contractSymbol);

self.RemoveOptionContract(self.contract_symbol)

The RemoveOptionContract method cancels your open orders for the contract and liquidates your holdings.

Properties

The AddOptionContract method returns an Option object, which have the following properties:

Introduction

LEAN passes the data you request to the OnData method so you can make trading decisions. The default OnData method accepts a Slice object, but you can define additional OnData methods that accept different data types. For example, if you define an OnData method that accepts a TradeBar argument, it only receives TradeBar objects. The Slice object that the OnData method receives groups all the data together at a single moment in time. To access the Slice outside of the OnData method, use the CurrentSlice property of your algorithm.

All the data formats use DataDictionary objects to group data by Symbol and provide easy access to information. The plural of the type denotes the collection of objects. For instance, the TradeBars DataDictionary is made up of TradeBar objects. To access individual data points in the dictionary, you can index the dictionary with the contract ticker or Symbol , but we recommend you use the Symbol .

Trades

TradeBar objects are price bars that consolidate individual trades from the exchanges. They contain the open, high, low, close, and volume of trading activity over a period of time.

TradeBar objects have the following properties:

To get the TradeBar objects in the Slice , index the Slice or index the Bars property of the Slice with the contract Symbol . If the contract doesn't actively trade or you are in the same time step as when you added the contract subscription, the Slice may not contain data for your Symbol . To avoid issues, check if the Slice contains data for your contract before you index the Slice with the contract Symbol .

public override void OnData(Slice slice)
{
    if (slice.Bars.ContainsKey(_contractSymbol))
    {
        var tradeBar = slice.Bars[_contractSymbol];
    }
}

public void OnData(TradeBars tradeBars)
{
    if (tradeBars.ContainsKey(_contractSymbol))
    {
        var tradeBar = tradeBars[_contractSymbol];
    }
}

def OnData(self, slice: Slice) -> None:
    if self.contract_symbol in slice.Bars:
        trade_bar = slice.Bars[self.contract_symbol]

You can also iterate through the TradeBars dictionary. The keys of the dictionary are the Symbol objects and the values are the TradeBar objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Bars)
    {
        var symbol = kvp.Key;
        var tradeBar = kvp.Value;
        var closePrice = tradeBar.Close;
    }
}

public void OnData(TradeBars tradeBars)
{
    foreach (var kvp in tradeBars)
    {
        var symbol = kvp.Key;
        var tradeBar = kvp.Value;
        var closePrice = tradeBar.Close;
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, trade_bar in slice.Bars.items():
        close_price = trade_bar.Close

Quotes

QuoteBar objects are bars that consolidate NBBO quotes from the exchanges. They contain the open, high, low, and close prices of the bid and ask. The Open , High , Low , and Close properties of the QuoteBar object are the mean of the respective bid and ask prices. If the bid or ask portion of the QuoteBar has no data, the Open , High , Low , and Close properties of the QuoteBar copy the values of either the Bid or Ask instead of taking their mean.

QuoteBar objects have the following properties:

To get the QuoteBar objects in the Slice , index the QuoteBars property of the Slice with the contract Symbol . If the contract doesn't actively get quotes or you are in the same time step as when you added the contract subscription, the Slice may not contain data for your Symbol . To avoid issues, check if the Slice contains data for your contract before you index the Slice with the contract Symbol .

public override void OnData(Slice slice)
{
    if (slice.QuoteBars.ContainsKey(_contractSymbol))
    {
        var quoteBar = slice.QuoteBars[_contractSymbol];
    }
}

public void OnData(QuoteBars quoteBars)
{
    if (quoteBars.ContainsKey(_contractSymbol))
    {
        var quoteBar = quoteBars[_contractSymbol];
    }
}

def OnData(self, slice: Slice) -> None:
    if self.contract_symbol in slice.QuoteBars:
        quote_bar = slice.QuoteBars[self.contract_symbol]

You can also iterate through the QuoteBars dictionary. The keys of the dictionary are the Symbol objects and the values are the QuoteBar objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.QuoteBars)
    {
        var symbol = kvp.Key;
        var quoteBar = kvp.Value;
        var askPrice = quoteBar.Ask.Close;
    }
}

public void OnData(QuoteBars quoteBars)
{
    foreach (var kvp in quoteBars)
    {
        var symbol = kvp.Key;
        var quoteBar = kvp.Value;
        var askPrice = quoteBar.Ask.Close;
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, quote_bar in slice.QuoteBars.items():
        ask_price = quote_bar.Ask.Close

QuoteBar objects let LEAN incorporate spread costs into your simulated trade fills to make backtest results more realistic.

Option Chains

OptionChain objects represent an entire chain of Option contracts for a single underlying security. They have the following properties:

To get the OptionChain , index the OptionChains property of the Slice with the canonical Symbol .

public override void OnData(Slice slice)
{
    if (slice.OptionChains.TryGetValue(_contractSymbol.Canonical, out var chain))
    {
        var contracts = chain.Contracts;
    }
}

public void OnData(OptionChains optionChains)
{
    if (optionChains.TryGetValue(_contractSymbol.Canonical, out var chain))
    {
        var contracts = chain.Contracts;
    }
}

def OnData(self, slice: Slice) -> None:
    chain = slice.OptionChains.get(self.contract_symbol.Canonical)
    if chain:
        contracts = chain.Contracts

You can also loop through the OptionChains property to get each OptionChain .

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.OptionChains)
    {
        var canonicalSymbol = kvp.Key;
        var chain = kvp.Value;
        var contracts = chain.Contracts;
    }
}

public void OnData(OptionChains optionChains)
{
    foreach (var kvp in optionChains)
    {
        var canonicalSymbol = kvp.Key;
        var chain = kvp.Value;
        var contracts = chain.Contracts;
    }
}

def OnData(self, slice: Slice) -> None:
    for canonical_symbol, chain in slice.OptionChains.items():
        contracts = chain.Contracts

Option Contracts

OptionContract objects represent the data of a single Option contract in the market. They have the following properties:

To get the Option contracts in the Slice , use the Contracts property of the OptionChain .

public override void OnData(Slice slice)
{
    if (slice.OptionChains.TryGetValue(_contractSymbol.Canonical, out var chain))
    {
        if (chain.Contracts.TryGetValue(_contractSymbol, out var contract))
        {
            var price = contract.Price;
        }
    }
}

public void OnData(OptionChains optionChains)
{
    if (optionChains.TryGetValue(_contractSymbol.Canonical, out var chain))
    {
        if (chain.Contracts.TryGetValue(_contractSymbol, out var contract))
        {
            var price = contract.Price;
        }
    }
}

def OnData(self, slice: Slice) -> None:
    chain = slice.OptionChains.get(self.contract_symbol.Canonical)
    if chain:
        contract = chain.Contracts.get(self.contract_symbol)
        if contract:
            price = contract.Price

Greeks and Implied Volatility

To get the Greeks and implied volatility of an Option contract, use the Greeks and ImpliedVolatility members.

public override void OnData(Slice slice)
{
    if (slice.OptionChains.TryGetValue(_contractSymbol.Canonical, out var chain))
    {
        if (chain.Contracts.TryGetValue(_contractSymbol, out var contract))
        {
            var delta = contract.Greeks.Delta;
            var iv = contract.ImpliedVolatility;
        }
    }
}

def OnData(self, slice: Slice) -> None:
    chain = slice.OptionChains.get(self.contract_symbol.Canonical)
    if chain:
        contract = chain.Contracts.get(self.contract_symbol)
        if contract:
            delta = contract.Greeks.Delta
            iv = contract.ImpliedVolatility

LEAN only calculates Greeks and implied volatility when you request them because they are expensive operations. If you invoke the Greeks member, the Greeks aren't calculated. However, if you invoke the Greeks.Delta member, LEAN calculates the delta. To avoid unecessary computation in your algorithm, only request the Greeks and implied volatility when you need them. For more information about the Greeks and implied volatility, see Options Pricing .

Open Interest

Open interest is the number of outstanding contracts that haven't been settled. It provides a measure of investor interest and the market liquidity, so it's a popular metric to use for contract selection. Open interest is calculated once per day. To get the latest open interest value, use the OpenInterest property of the Option or OptionContract .

public override void OnData(Slice slice)
{
    if (slice.OptionChains.TryGetValue(_contractSymbol.Canonical, out var chain))
    {
        if (chain.Contracts.TryGetValue(_contractSymbol, out var contract))
        {
            var openInterest = contract.OpenInterest;
        }
    }
}

public void OnData(OptionChains optionChains)
{
    if (optionChains.TryGetValue(_contractSymbol.Canonical, out var chain))
    {
        if (chain.Contracts.TryGetValue(_contractSymbol, out var contract))
        {
            var openInterest = contract.OpenInterest;
        }
    }
}

def OnData(self, slice: Slice) -> None:
    chain = slice.OptionChains.get(self.contract_symbol.Canonical)
    if chain:
        contract = chain.Contracts.get(self.contract_symbol)
        if contract:
            open_interest = contract.OpenInterest

Introduction

This page shows the trading hours, holidays, and time zone of the Equity Option market.

Pre-market Hours

Pre-market trading is not available.

Regular Trading Hours

The following table shows the regular trading hours for the Equity Option market:

Post-market Hours

Post-market trading is not available.

Holidays

LEAN uses the trading holidays from the NYSE website.

The following table shows the dates of holidays for the Equity Option market:

Early Closes

The following table shows the early closes for the Equity Option market:

Late Opens

There are no days with late opens.

Time Zone

The Equity Option market trades in the America/New York time zone.

Introduction

Request Crypto data in your algorithm to receive a feed of asset prices in the OnData method. For more information about the specific datasets we use for backtests, see the CoinAPI datasets . To trade Crypto live, you can use our Crypto data feed .

Create Subscriptions

To create a Crypto subscription, in the Initialize method, call the AddCrypto method. The AddCrypto method returns a Crypto object, which contains a Symbol . Save a reference to the Symbol so you can use it in OnData to access the security data in the Slice .

_symbol = AddCrypto("BTCUSD").Symbol;

self.symbol = self.AddCrypto("BTCUSD").Symbol

The AddCrypto method creates a subscription for a single Crypto asset and adds it to your user-defined universe. To create a dynamic universe of Crypto assets, add a Crypto universe .

To view the supported assets, see the CoinAPI datasets .

Fungible Assets

Fungible assets are assets that are interchangeable with each other. For example, every Bitcoin is effectively identical to every other Bitcoin. In contrast, non-fungible tokens (NFTs) are non-fungible because each one is unique. An example of an NFT is the Bored Ape Yacht Club collection. LEAN doesn't currently support trading NFTs.

Resolutions

The following table shows the available resolutions and data formats for Crypto subscriptions:

Resolution	TradeBar	QuoteBar	Trade Tick	Quote Tick
Tick
Second
Minute
Hour
Daily

The default resolution for Crypto subscriptions is Resolution.Minute . To change the resolution, pass a resolution argument to the AddCrypto method.

_symbol = AddCrypto("BTCUSD", Resolution.Daily).Symbol;

self.symbol = self.AddCrypto("BTCUSD", Resolution.Daily).Symbol

To create custom resolution periods, see Consolidating Data .

Supported Markets

The following Market enumeration members are available for Crypto:

To set the market for a security, pass a market argument to the AddCrypto method.

_symbol = AddCrypto("BTCUSD", market: Market.GDAX).Symbol;

self.symbol = self.AddCrypto("BTCUSD", market=Market.GDAX).Symbol

The brokerage models have a default market for each asset class. If you set a brokerage model, you may not need to specify the market to use.

Fill Forward

Fill forward means if there is no data point for the current slice , LEAN uses the previous data point. Fill forward is the default data setting. If you disable fill forward, you may get stale fills or you may see trade volume as zero.

To disable fill forward for a security, set the fillForward argument to false when you create the security subscription.

_symbol = AddCrypto("BTCUSD", fillForward: false).Symbol;

self.symbol = self.AddCrypto("BTCUSD", fillForward=False).Symbol

Margin and Leverage

LEAN models buying power and margin calls to ensure your algorithm stays within the margin requirements. The amount of leverage available to you depends on the brokerage you use. To change the amount of leverage you can use for a security, pass a leverage argument to the AddCrypto method.

_symbol = AddCrypto("BTCUSD", leverage: 3).Symbol;

self.symbol = self.AddCrypto("BTCUSD", leverage=3).Symbol

For more information about the leverage each brokerage provides, see Brokerages .

Properties

The AddCrypto method returns a Crypto object, which have the following properties:

Introduction

LEAN passes the data you request to the OnData method so you can make trading decisions. The default OnData method accepts a Slice object, but you can define additional OnData methods that accept different data types. For example, if you define an OnData method that accepts a TradeBar argument, it only receives TradeBar objects. The Slice object that the OnData method receives groups all the data together at a single moment in time. To access the Slice outside of the OnData method, use the CurrentSlice property of your algorithm.

All the data formats use DataDictionary objects to group data by Symbol and provide easy access to information. The plural of the type denotes the collection of objects. For instance, the TradeBars DataDictionary is made up of TradeBar objects. To access individual data points in the dictionary, you can index the dictionary with the security ticker or Symbol , but we recommend you use the Symbol .

Trades

TradeBar objects are price bars that consolidate individual trades from the exchanges. They contain the open, high, low, close, and volume of trading activity over a period of time.

TradeBar objects have the following properties:

To get the TradeBar objects in the Slice , index the Slice or index the Bars property of the Slice with the security Symbol . If the security doesn't actively trade or you are in the same time step as when you added the security subscription, the Slice may not contain data for your Symbol . To avoid issues, check if the Slice contains data for your security before you index the Slice with the security Symbol .

public override void OnData(Slice slice)
{
    if (slice.Bars.ContainsKey(_symbol))
    {
        var tradeBar = slice.Bars[_symbol];
    }
}

public void OnData(TradeBars tradeBars)
{
    if (tradeBars.ContainsKey(_symbol))
    {
        var tradeBar = tradeBars[_symbol];
    }
}

def OnData(self, slice: Slice) -> None:
    if self.symbol in slice.Bars:
        trade_bar = slice.Bars[self.symbol]

You can also iterate through the TradeBars dictionary. The keys of the dictionary are the Symbol objects and the values are the TradeBar objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Bars)
    {
        var symbol = kvp.Key;
        var tradeBar = kvp.Value;
        var closePrice = tradeBar.Close;
    }
}

public void OnData(TradeBars tradeBars)
{
    foreach (var kvp in tradeBars)
    {
        var symbol = kvp.Key;
        var tradeBar = kvp.Value;
        var closePrice = tradeBar.Close;
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, trade_bar in slice.Bars.items():
        close_price = trade_bar.Close

Quotes

QuoteBar objects are bars that consolidate NBBO quotes from the exchanges. They contain the open, high, low, and close prices of the bid and ask. The Open , High , Low , and Close properties of the QuoteBar object are the mean of the respective bid and ask prices. If the bid or ask portion of the QuoteBar has no data, the Open , High , Low , and Close properties of the QuoteBar copy the values of either the Bid or Ask instead of taking their mean.

QuoteBar objects have the following properties:

To get the QuoteBar objects in the Slice , index the QuoteBars property of the Slice with the security Symbol . If the security doesn't actively get quotes or you are in the same time step as when you added the security subscription, the Slice may not contain data for your Symbol . To avoid issues, check if the Slice contains data for your security before you index the Slice with the security Symbol .

public override void OnData(Slice slice)
{
    if (slice.QuoteBars.ContainsKey(_symbol))
    {
        var quoteBar = slice.QuoteBars[_symbol];
    }
}

public void OnData(QuoteBars quoteBars)
{
    if (quoteBars.ContainsKey(_symbol))
    {
        var quoteBar = quoteBars[_symbol];
    }
}

def OnData(self, slice: Slice) -> None:
    if self.symbol in slice.QuoteBars:
        quote_bar = slice.QuoteBars[self.symbol]

You can also iterate through the QuoteBars dictionary. The keys of the dictionary are the Symbol objects and the values are the QuoteBar objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.QuoteBars)
    {
        var symbol = kvp.Key;
        var quoteBar = kvp.Value;
        var askPrice = quoteBar.Ask.Close;
    }
}

public void OnData(QuoteBars quoteBars)
{
    foreach (var kvp in quoteBars)
    {
        var symbol = kvp.Key;
        var quoteBar = kvp.Value;
        var askPrice = quoteBar.Ask.Close;
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, quote_bar in slice.QuoteBars.items():
        ask_price = quote_bar.Ask.Close

QuoteBar objects let LEAN incorporate spread costs into your simulated trade fills to make backtest results more realistic.

Ticks

Tick objects represent a single trade or quote at a moment in time. A trade tick is a record of a transaction for the security. A quote tick is an offer to buy or sell the security at a specific price. Tick objects have the following properties:

Trade ticks have a non-zero value for the Quantity and Price properties, but they have a zero value for the BidPrice , BidSize , AskPrice , and AskSize properties. Quote ticks have non-zero values for BidPrice and BidSize properties or have non-zero values for AskPrice and AskSize properties. To check if a tick is a trade or a quote, use the TickType property.

In backtests, LEAN groups ticks into one millisecond buckets. In live trading, LEAN groups ticks into ~70-millisecond buckets. To get the Tick objects in the Slice , index the Ticks property of the Slice with a Symbol . If the security doesn't actively trade or you are in the same time step as when you added the security subscription, the Slice may not contain data for your Symbol . To avoid issues, check if the Slice contains data for your security before you index the Slice with the security Symbol .

public override void OnData(Slice slice)
{
    if (slice.Ticks.ContainsKey(_symbol))
    {
        var ticks = slice.Ticks[_symbol];
        foreach (var tick in ticks)
        {
            var price = tick.Price;
        }
    }
}

public void OnData(Ticks ticks)
{
    if (ticks.ContainsKey(_symbol))
    {
        foreach (var tick in ticks[_symbol])
        {
            var price = tick.Price;
        }
    }
}

def OnData(self, slice: Slice) -> None:
    if self.symbol in slice.Ticks:
        ticks = slice.Ticks[self.symbol]
        for tick in ticks:
            price = tick.Price

You can also iterate through the Ticks dictionary. The keys of the dictionary are the Symbol objects and the values are the List<Tick> list[Tick] objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Ticks)
    {
        var symbol = kvp.Key;
        var ticks = kvp.Value;
        foreach (var tick in ticks)
        {
            var price = tick.Price;
        }
    }
}

public void OnData(Ticks ticks)
{
    foreach (var kvp in ticks)
    {
        var symbol = kvp.Key;
        foreach (var tick in kvp.Value)
        {
            var price = tick.Price;
        }
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, ticks in slice.Ticks.items():
        for tick in ticks:
            price = tick.Price

Tick data is raw and unfiltered, so it can contain bad ticks that skew your trade results. For example, some ticks come from dark pools, which aren't tradable. We recommend you only use tick data if you understand the risks and are able to perform your own online tick filtering.

Introduction

Crypto holdings require special consideration because not all brokerages track your positions in each currency pair.

Cash vs Margin Brokerage Accounts

Some of the Crypto brokerages integrated into QuantConnect support cash and margin accounts while some only support cash accounts. If you want to short Crypto assets or use leverage, you need a margin account. Follow these steps to view which account types each brokerage supports:

1. Open the brokerage guides .
2. Click a Crypto brokerage.
3. Scroll down to the Account Types section.

Virtual Pairs

All fiat and Crypto currencies are individual assets. When you buy a pair like BTCUSD, you trade USD for BTC. In this case, LEAN removes some USD from your portfolio cashbook and adds some BTC. The virtual pair BTCUSD represents your position in that trade, but the virtual pair doesn't actually exist. It simply represents an open trade. If you call the Liquidate method with the Symbol of a virtual pair, the method only liquidates the quantity in your virtual pair. For more information about liquidating Crypto postitions, see Crypto Trades .

Access Cypto Holdings

The CashBook stores the quantity of your Crypto holdings. To access your Crypto holdings, index the CashBook with the currency ticker. The values of the CashBook dictionary are Cash objects, which have the following properties:

var btcQuantity = Portfolio.CashBook["BTC"].Amount;
var btcValue = Portfolio.CashBook["BTC"].ValueInAccountCurrency;

btc_quantity = self.Portfolio.CashBook['BTC'].Amount
btc_value = self.Portfolio.CashBook['BTC'].ValueInAccountCurrency

To access the virtual pair of your Crypto trades, index the Portfolio object with the pair Symbol .

var securityHolding = Portfolio[_btcUsdSymbol];

security_holding  = self.Portfolio[self.btc_usd_symbol]

Stateful Redeployments

When you make a trade inside of a running algorithm, LEAN tracks the virtual position state for you, but it won't survive between deployments. Some brokerages save your virtual pairs, so you can load them into your algorithm when you stop and redeploy it. Depending on the brokerage you select, you may be able to manually add virtual pairs when you deploy live algorithms with the LEAN CLI or cloud deployment wizard .

Introduction

The Crypto markets are open 24/7. There are no pre-market hours, post-market hours, holidays, late opens, or early closes.

Introduction

Request Crypto Futures data in your algorithm to receive a feed of asset prices in the OnData method. For more information about the specific datasets we use for backtests, see the Binance Crypto Future Price Data dataset listing . To trade Crypto live, you can use our Crypto Futures data feed .

Create Subscriptions

To create a Crypto Futures subscription, in the Initialize method, call the AddCryptoFuture method. The AddCryptoFuture method returns a CryptoFuture object, which contains a Symbol . Save a reference to the Symbol so you can use it in OnData to access the security data in the Slice .

_symbol = AddCryptoFuture("BTCUSD").Symbol;

self.symbol = self.AddCryptoFuture("BTCUSD").Symbol

The AddCryptoFuture method creates a subscription for a single Crypto Futures asset and adds it to your user-defined universe.

To view the supported assets in the Crypto Futures dataset, see Supported Assets .

Resolutions

The following table shows the available resolutions and data formats for Crypto Futures contract subscriptions:

Resolution	TradeBar	QuoteBar	Trade Tick	Quote Tick
Tick
Second
Minute
Hour
Daily

The default resolution for Crypto Futures subscriptions is Resolution.Minute . To change the resolution, pass a resolution argument to the AddCryptoFuture method.

_symbol = AddCryptoFuture("BTCUSD", Resolution.Daily).Symbol;

self.symbol = self.AddCryptoFuture("BTCUSD", Resolution.Daily).Symbol

To create custom resolution periods, see Consolidating Data .

Supported Markets

Crypto Futures are currently only available on Market.Binance . To set the market for a security, pass a market argument to the AddCryptoFuture method.

_symbol = AddCryptoFuture("BTCUSD", market: Market.Binance).Symbol;

self.symbol = self.AddCryptoFuture("BTCUSD", market=Market.Binance).Symbol

The brokerage models have a default market for each asset class. If you set a brokerage model, you may not need to specify the market to use.

Fill Forward

Fill forward means if there is no data point for the current slice , LEAN uses the previous data point. Fill forward is the default data setting. If you disable fill forward, you may get stale fills or you may see trade volume as zero.

To disable fill forward for a security, set the fillForward argument to false when you create the security subscription.

_symbol = AddCryptoFuture("BTCUSD", fillForward: false).Symbol;

self.symbol = self.AddCryptoFuture("BTCUSD", fillForward=False).Symbol

Margin and Leverage

LEAN models buying power and margin calls to ensure your algorithm stays within the margin requirements. The amount of leverage available to you depends on the brokerage you use. To change the amount of leverage you can use for a security, pass a leverage argument to the AddCryptoFuture method.

_symbol = AddCryptoFuture("BTCUSD", leverage: 3).Symbol;

self.symbol = self.AddCryptoFuture("BTCUSD", leverage=3).Symbol

For more information about the leverage each brokerage provides, see Brokerages .

Properties

The AddCryptoFuture method returns a CryptoFuture object, which have the following properties:

Introduction

LEAN passes the data you request to the OnData method so you can make trading decisions. The default OnData method accepts a Slice object, but you can define additional OnData methods that accept different data types. For example, if you define an OnData method that accepts a TradeBar argument, it only receives TradeBar objects. The Slice object that the OnData method receives groups all the data together at a single moment in time. To access the Slice outside of the OnData method, use the CurrentSlice property of your algorithm.

All the data formats use DataDictionary objects to group data by Symbol and provide easy access to information. The plural of the type denotes the collection of objects. For instance, the TradeBars DataDictionary is made up of TradeBar objects. To access individual data points in the dictionary, you can index the dictionary with the security ticker or Symbol , but we recommend you use the Symbol .

Trades

TradeBar objects are price bars that consolidate individual trades from the exchanges. They contain the open, high, low, close, and volume of trading activity over a period of time.

TradeBar objects have the following properties:

To get the TradeBar objects in the Slice , index the Slice or index the Bars property of the Slice with the security Symbol . If the security doesn't actively trade or you are in the same time step as when you added the security subscription, the Slice may not contain data for your Symbol . To avoid issues, check if the Slice contains data for your security before you index the Slice with the security Symbol .

public override void OnData(Slice slice)
{
    if (slice.Bars.ContainsKey(_symbol))
    {
        var tradeBar = slice.Bars[_symbol];
    }
}

public void OnData(TradeBars tradeBars)
{
    if (tradeBars.ContainsKey(_symbol))
    {
        var tradeBar = tradeBars[_symbol];
    }
}

def OnData(self, slice: Slice) -> None:
    if self.symbol in slice.Bars:
        trade_bar = slice.Bars[self.symbol]

You can also iterate through the TradeBars dictionary. The keys of the dictionary are the Symbol objects and the values are the TradeBar objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Bars)
    {
        var symbol = kvp.Key;
        var tradeBar = kvp.Value;
        var closePrice = tradeBar.Close;
    }
}

public void OnData(TradeBars tradeBars)
{
    foreach (var kvp in tradeBars)
    {
        var symbol = kvp.Key;
        var tradeBar = kvp.Value;
        var closePrice = tradeBar.Close;
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, trade_bar in slice.Bars.items():
        close_price = trade_bar.Close

Quotes

QuoteBar objects are bars that consolidate NBBO quotes from the exchanges. They contain the open, high, low, and close prices of the bid and ask. The Open , High , Low , and Close properties of the QuoteBar object are the mean of the respective bid and ask prices. If the bid or ask portion of the QuoteBar has no data, the Open , High , Low , and Close properties of the QuoteBar copy the values of either the Bid or Ask instead of taking their mean.

QuoteBar objects have the following properties:

To get the QuoteBar objects in the Slice , index the QuoteBars property of the Slice with the security Symbol . If the security doesn't actively get quotes or you are in the same time step as when you added the security subscription, the Slice may not contain data for your Symbol . To avoid issues, check if the Slice contains data for your security before you index the Slice with the security Symbol .

public override void OnData(Slice slice)
{
    if (slice.QuoteBars.ContainsKey(_symbol))
    {
        var quoteBar = slice.QuoteBars[_symbol];
    }
}

public void OnData(QuoteBars quoteBars)
{
    if (quoteBars.ContainsKey(_symbol))
    {
        var quoteBar = quoteBars[_symbol];
    }
}

def OnData(self, slice: Slice) -> None:
    if self.symbol in slice.QuoteBars:
        quote_bar = slice.QuoteBars[self.symbol]

You can also iterate through the QuoteBars dictionary. The keys of the dictionary are the Symbol objects and the values are the QuoteBar objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.QuoteBars)
    {
        var symbol = kvp.Key;
        var quoteBar = kvp.Value;
        var askPrice = quoteBar.Ask.Close;
    }
}

public void OnData(QuoteBars quoteBars)
{
    foreach (var kvp in quoteBars)
    {
        var symbol = kvp.Key;
        var quoteBar = kvp.Value;
        var askPrice = quoteBar.Ask.Close;
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, quote_bar in slice.QuoteBars.items():
        ask_price = quote_bar.Ask.Close

QuoteBar objects let LEAN incorporate spread costs into your simulated trade fills to make backtest results more realistic.

Ticks

Tick objects represent a single trade or quote at a moment in time. A trade tick is a record of a transaction for the security. A quote tick is an offer to buy or sell the security at a specific price. Tick objects have the following properties:

Trade ticks have a non-zero value for the Quantity and Price properties, but they have a zero value for the BidPrice , BidSize , AskPrice , and AskSize properties. Quote ticks have non-zero values for BidPrice and BidSize properties or have non-zero values for AskPrice and AskSize properties. To check if a tick is a trade or a quote, use the TickType property.

In backtests, LEAN groups ticks into one millisecond buckets. In live trading, LEAN groups ticks into ~70-millisecond buckets. To get the Tick objects in the Slice , index the Ticks property of the Slice with a Symbol . If the security doesn't actively trade or you are in the same time step as when you added the security subscription, the Slice may not contain data for your Symbol . To avoid issues, check if the Slice contains data for your security before you index the Slice with the security Symbol .

public override void OnData(Slice slice)
{
    if (slice.Ticks.ContainsKey(_symbol))
    {
        var ticks = slice.Ticks[_symbol];
        foreach (var tick in ticks)
        {
            var price = tick.Price;
        }
    }
}

public void OnData(Ticks ticks)
{
    if (ticks.ContainsKey(_symbol))
    {
        foreach (var tick in ticks[_symbol])
        {
            var price = tick.Price;
        }
    }
}

def OnData(self, slice: Slice) -> None:
    if self.symbol in slice.Ticks:
        ticks = slice.Ticks[self.symbol]
        for tick in ticks:
            price = tick.Price

You can also iterate through the Ticks dictionary. The keys of the dictionary are the Symbol objects and the values are the List<Tick> list[Tick] objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Ticks)
    {
        var symbol = kvp.Key;
        var ticks = kvp.Value;
        foreach (var tick in ticks)
        {
            var price = tick.Price;
        }
    }
}

public void OnData(Ticks ticks)
{
    foreach (var kvp in ticks)
    {
        var symbol = kvp.Key;
        foreach (var tick in kvp.Value)
        {
            var price = tick.Price;
        }
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, ticks in slice.Ticks.items():
        for tick in ticks:
            price = tick.Price

Tick data is raw and unfiltered, so it can contain bad ticks that skew your trade results. For example, some ticks come from dark pools, which aren't tradable. We recommend you only use tick data if you understand the risks and are able to perform your own online tick filtering.

Margin Interest Rates

MarginInterestRate objects contain the margin interest rate, which is a cost associated with trading on margin. MarginInterestRate objects have the following properties:

To get the MarginInterestRate objects in the Slice , index the MarginInterestRate property of the Slice with the Crypto Future Symbol . The MarginInterestRate property of the Slice may not contain data for your Symbol . To avoid issues, check if the property contains data for your Crypto Future before you index it with the Crypto Future Symbol .

public override void OnData(Slice slice)
{
    if (slice.MarginInterestRates.ContainsKey(_symbol))
    {
        var interestRate = slice.MarginInterestRates[_symbol].InterestRate;
    }
}

def OnData(self, slice: Slice) -> None:
    if self.symbol in slice.MarginInterestRates:
        interest_rate = slice.MarginInterestRates[self.symbol].InterestRate

You can also iterate through the MarginInterestRates dictionary. The keys of the dictionary are the Symbol objects and the values are the MarginInterestRate objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.MarginInterestRates)
    {
        var symbol = kvp.Key;
        var marginInterestRate = kvp.Value;
        var interestRate = marginInterestRate.InterestRate;
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, margin_interest_rate in slice.MarginInterestRates.items():
        interest_rate = margin_interest_rate.InterestRate

Introduction

The Crypto Futures markets are open 24/7. There are no pre-market hours, post-market hours, holidays, late opens, or early closes.

Introduction

Request Forex data in your algorithm to receive a feed of exchange rates in the OnData method. For more information about the specific dataset we use for backtests, see the FOREX dataset listing . To trade Forex live, you can use our Forex data feed .

Create Subscriptions

To create a Forex pair subscription, in the Initialize method, call the AddForex method. The AddForex method returns a Forex object, which contains a Symbol . Save a reference to the Symbol so you can use it in OnData to access the security data in the Slice .

_symbol = AddForex("EURUSD").Symbol;

self.symbol = self.AddForex("EURUSD").Symbol

To view the supported Forex pairs, see Supported Assets .

Resolutions

The following table shows the available resolutions and data formats for Forex subscriptions:

Resolution	TradeBar	QuoteBar	Trade Tick	Quote Tick
Tick
Second
Minute
Hour
Daily

The default resolution for Forex subscriptions is Resolution.Minute . To change the resolution, pass a resolution argument to the AddForex method.

_symbol = AddForex("EURUSD", Resolution.Daily).Symbol;

self.symbol = self.AddForex("EURUSD", Resolution.Daily).Symbol

To create custom resolution periods, see Consolidating Data .

Supported Markets

The only market available for Forex pairs is Market.Oanda , so you don't need to pass a market argument to the AddForex method.

_symbol = AddForex("EURUSD", market: Market.Oanda).Symbol;

self.symbol = self.AddForex("EURUSD", market=Market.Oanda).Symbol

The brokerage models have a default market for each asset class. If you set a brokerage model, you may not need to specify the market to use.

Fill Forward

Fill forward means if there is no data point for the current slice , LEAN uses the previous data point. Fill forward is the default data setting. If you disable fill forward, you may get stale fills or you may see trade volume as zero.

To disable fill forward for a security, set the fillForward argument to false when you create the security subscription.

_symbol = AddForex("EURUSD", fillForward: false).Symbol;

self.symbol = self.AddForex("EURUSD", fillForward=False).Symbol

Margin and Leverage

LEAN models buying power and margin calls to ensure your algorithm stays within the margin requirements. The Oanda brokerage let's you use up to 50x leverage on margin accounts. To change the amount of leverage you can use for a Forex pair, pass a leverage argument to the AddForex method.

_symbol = AddForex("EURUSD", leverage: 35).Symbol;

self.symbol = self.AddForex("EURUSD", leverage=35).Symbol

Properties

The AddForex method returns a Forex object, which have the following properties:

Introduction

LEAN passes the data you request to the OnData method so you can make trading decisions. The default OnData method accepts a Slice object, but you can define additional OnData methods that accept different data types. For example, if you define an OnData method that accepts a QuoteBar argument, it only receives QuoteBar objects. The Slice object that the OnData method receives groups all the data together at a single moment in time. To access the Slice outside of the OnData method, use the CurrentSlice property of your algorithm.

All the data formats use DataDictionary objects to group data by Symbol and provide easy access to information. The plural of the type denotes the collection of objects. For instance, the QuoteBars DataDictionary is made up of QuoteBar objects. To access individual data points in the dictionary, you can index the dictionary with the Forex pair ticker or Symbol , but we recommend you use the Symbol .

Quotes

QuoteBar objects are bars that consolidate NBBO quotes from the exchanges. They contain the open, high, low, and close prices of the bid and ask. The Open , High , Low , and Close properties of the QuoteBar object are the mean of the respective bid and ask prices. If the bid or ask portion of the QuoteBar has no data, the Open , High , Low , and Close properties of the QuoteBar copy the values of either the Bid or Ask instead of taking their mean.

QuoteBar objects have the following properties:

To get the QuoteBar objects in the Slice , index the QuoteBars property of the Slice with the Forex pair Symbol . If the Forex pair doesn't actively get quotes or you are in the same time step as when you added the Forex pair subscription, the Slice may not contain data for your Symbol . To avoid issues, check if the Slice contains data for your Forex pair before you index the Slice with the Forex pair Symbol .

public override void OnData(Slice slice)
{
    if (slice.QuoteBars.ContainsKey(_symbol))
    {
        var quoteBar = slice.QuoteBars[_symbol];
    }
}

public void OnData(QuoteBars quoteBars)
{
    if (quoteBars.ContainsKey(_symbol))
    {
        var quoteBar = quoteBars[_symbol];
    }
}

def OnData(self, slice: Slice) -> None:
    if self.symbol in slice.QuoteBars:
        quote_bar = slice.QuoteBars[self.symbol]

You can also iterate through the QuoteBars dictionary. The keys of the dictionary are the Symbol objects and the values are the QuoteBar objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.QuoteBars)
    {
        var symbol = kvp.Key;
        var quoteBar = kvp.Value;
        var askPrice = quoteBar.Ask.Close;
    }
}

public void OnData(QuoteBars quoteBars)
{
    foreach (var kvp in quoteBars)
    {
        var symbol = kvp.Key;
        var quoteBar = kvp.Value;
        var askPrice = quoteBar.Ask.Close;
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, quote_bar in slice.QuoteBars.items():
        ask_price = quote_bar.Ask.Close

QuoteBar objects let LEAN incorporate spread costs into your simulated trade fills to make backtest results more realistic.

Ticks

Tick objects represent a single trade or quote at a moment in time. A trade tick is a record of a transaction for the Forex pair. A quote tick is an offer to buy or sell the Forex pair at a specific price. Tick objects have the following properties:

Trade ticks have a non-zero value for the Quantity and Price properties, but they have a zero value for the BidPrice , BidSize , AskPrice , and AskSize properties. Quote ticks have non-zero values for BidPrice and BidSize properties or have non-zero values for AskPrice and AskSize properties. To check if a tick is a trade or a quote, use the TickType property.

In backtests, LEAN groups ticks into one millisecond buckets. In live trading, LEAN groups ticks into ~70-millisecond buckets. To get the Tick objects in the Slice , index the Ticks property of the Slice with a Symbol . If the Forex pair doesn't actively trade or you are in the same time step as when you added the Forex pair subscription, the Slice may not contain data for your Symbol . To avoid issues, check if the Slice contains data for your Forex pair before you index the Slice with the Forex pair Symbol .

public override void OnData(Slice slice)
{
    if (slice.Ticks.ContainsKey(_symbol))
    {
        var ticks = slice.Ticks[_symbol];
        foreach (var tick in ticks)
        {
            var price = tick.Price;
        }
    }
}

public void OnData(Ticks ticks)
{
    if (ticks.ContainsKey(_symbol))
    {
        foreach (var tick in ticks[_symbol])
        {
            var price = tick.Price;
        }
    }
}

def OnData(self, slice: Slice) -> None:
    if self.symbol in slice.Ticks:
        ticks = slice.Ticks[self.symbol]
        for tick in ticks:
            price = tick.Price

You can also iterate through the Ticks dictionary. The keys of the dictionary are the Symbol objects and the values are the List<Tick> list[Tick] objects.

public override void OnData(Slice slice)
{
    foreach (var kvp in slice.Ticks)
    {
        var symbol = kvp.Key;
        var ticks = kvp.Value;
        foreach (var tick in ticks)
        {
            var price = tick.Price;
        }
    }
}

public void OnData(Ticks ticks)
{
    foreach (var kvp in ticks)
    {
        var symbol = kvp.Key;
        foreach (var tick in kvp.Value)
        {
            var price = tick.Price;
        }
    }
}

def OnData(self, slice: Slice) -> None:
    for symbol, ticks in slice.Ticks.items():
        for tick in ticks:
            price = tick.Price

Tick data is raw and unfiltered, so it can contain bad ticks that skew your trade results. For example, some ticks come from dark pools, which aren't tradable. We recommend you only use tick data if you understand the risks and are able to perform your own online tick filtering.

Introduction

Pre-market Hours

Pre-market trading is not available.

Regular Trading Hours

The following table shows the regular trading hours for the Forex market:

Post-market Hours

Post-market trading is not available.

Holidays

The following table shows the dates of holidays for the Forex market:

Early Closes

The following table shows the early closes for the Forex market:

Late Opens

The following table shows the late opens for the Forex market:

Time Zone

The Forex market trades in the America/New York time zone.

Assets With Other Hours

The following list shows the pairs that have different trading periods than the overall Forex market:

• EURNZD
• GBPNZD
• NZDCAD
• NZDCHF
• NZDHKD
• NZDJPY
• NZDSGD
• NZDUSD

Introduction

This page shows the trading hours, holidays, and time zone of the EUR/NZD pair in the Forex market.

Pre-market Hours

Pre-market trading is not available.

Regular Trading Hours

The following table shows the regular trading hours for the EUR/NZD pair in the Forex market:

Post-market Hours

Post-market trading is not available.

Holidays

The following table shows the dates of holidays for the EUR/NZD pair in the Forex market:

Early Closes

The following table shows the early closes for the EUR/NZD pair in the Forex market:

Late Opens

The following table shows the late opens for the EUR/NZD pair in the Forex market:

Time Zone

The EUR/NZD pair in the Forex market trades in the America/New York time zone.

Introduction

This page shows the trading hours, holidays, and time zone of the GBP/NZD pair in the Forex market.

Pre-market Hours

Pre-market trading is not available.

Regular Trading Hours

The following table shows the regular trading hours for the GBP/NZD pair in the Forex market:

Post-market Hours

Post-market trading is not available.

Holidays

The following table shows the dates of holidays for the GBP/NZD pair in the Forex market:

Early Closes

The following table shows the early closes for the GBP/NZD pair in the Forex market:

Late Opens

The following table shows the late opens for the GBP/NZD pair in the Forex market:

Time Zone

The GBP/NZD pair in the Forex market trades in the America/New York time zone.

Introduction

This page shows the trading hours, holidays, and time zone of the NZD/CAD pair in the Forex market.

Pre-market Hours

Pre-market trading is not available.

Regular Trading Hours

The following table shows the regular trading hours for the NZD/CAD pair in the Forex market:

Post-market Hours

Post-market trading is not available.

Holidays

The following table shows the dates of holidays for the NZD/CAD pair in the Forex market:

Early Closes

The following table shows the early closes for the NZD/CAD pair in the Forex market:

Late Opens

The following table shows the late opens for the NZD/CAD pair in the Forex market:

Time Zone

The NZD/CAD pair in the Forex market trades in the America/New York time zone.

Introduction

This page shows the trading hours, holidays, and time zone of the NZD/CHF pair in the Forex market.

Pre-market Hours

Pre-market trading is not available.

Regular Trading Hours

The following table shows the regular trading hours for the NZD/CHF pair in the Forex market:

Post-market Hours

Post-market trading is not available.

Holidays

The following table shows the dates of holidays for the NZD/CHF pair in the Forex market:

Early Closes

The following table shows the early closes for the NZD/CHF pair in the Forex market:

Late Opens

The following table shows the late opens for the NZD/CHF pair in the Forex market:

Time Zone

The NZD/CHF pair in the Forex market trades in the America/New York time zone.

Introduction

This page shows the trading hours, holidays, and time zone of the NZD/HKD pair in the Forex market.

Pre-market Hours

Pre-market trading is not available.

Regular Trading Hours

The following table shows the regular trading hours for the NZD/HKD pair in the Forex market:

Post-market Hours

Post-market trading is not available.

Holidays

The following table shows the dates of holidays for the NZD/HKD pair in the Forex market:

Early Closes

The following table shows the early closes for the NZD/HKD pair in the Forex market:

Late Opens

The following table shows the late opens for the NZD/HKD pair in the Forex market:

Time Zone

The NZD/HKD pair in the Forex market trades in the America/New York time zone.

Introduction

This page shows the trading hours, holidays, and time zone of the NZD/JPY pair in the Forex market.

Pre-market Hours

Pre-market trading is not available.

Regular Trading Hours

The following table shows the regular trading hours for the NZD/JPY pair in the Forex market:

Post-market Hours

Post-market trading is not available.

Holidays

The following table shows the dates of holidays for the NZD/JPY pair in the Forex market:

Early Closes

The following table shows the early closes for the NZD/JPY pair in the Forex market:

Late Opens

The following table shows the late opens for the NZD/JPY pair in the Forex market:

Time Zone

The NZD/JPY pair in the Forex market trades in the America/New York time zone.

Introduction

This page shows the trading hours, holidays, and time zone of the NZD/SGD pair in the Forex market.

Pre-market Hours

Pre-market trading is not available.

Regular Trading Hours

The following table shows the regular trading hours for the NZD/SGD pair in the Forex market:

Post-market Hours

Post-market trading is not available.

Holidays

The following table shows the dates of holidays for the NZD/SGD pair in the Forex market:

Early Closes

The following table shows the early closes for the NZD/SGD pair in the Forex market:

Late Opens

The following table shows the late opens for the NZD/SGD pair in the Forex market:

Time Zone

The NZD/SGD pair in the Forex market trades in the America/New York time zone.

Introduction

This page shows the trading hours, holidays, and time zone of the NZD/USD pair in the Forex market.

Pre-market Hours

Pre-market trading is not available.

Regular Trading Hours

The following table shows the regular trading hours for the NZD/USD pair in the Forex market:

Post-market Hours

Post-market trading is not available.

Holidays

The following table shows the dates of holidays for the NZD/USD pair in the Forex market:

Early Closes

The following table shows the early closes for the NZD/USD pair in the Forex market:

Late Opens

The following table shows the late opens for the NZD/USD pair in the Forex market:

Time Zone

The NZD/USD pair in the Forex market trades in the America/New York time zone.

Introduction

Request Futures data in your algorithm to receive a feed of contract prices in the OnData method. For more information about the specific dataset we use for backtests, see the US Futures dataset listing . To trade Futures live, you can use our Futures data feed or one of the brokerage data feeds .

Create Subscriptions

Before you can subscribe to a Futures contract, you must get the contract Symbol .

Get Contract Symbols

To get Futures contract Symbol objects, call the CreateFuture method or use the FutureChainProvider . If you use the CreateFuture method, you need to know the specific contract details.

_contractSymbol = QuantConnect.Symbol.CreateFuture(Futures.Indices.SP500EMini,
    Market.CME, new DateTime(2022, 6, 17));

self.contract_symbol = Symbol.CreateFuture(Futures.Indices.SP500EMini,
    Market.CME, datetime(2022,6,17))

If you use the FutureChainProvider , you need to create the continuous contract Symbol of the Future. The GetFutureContractList method of FutureChainProvider returns a list of Symbol objects that reference the available Futures contracts for a given underlying Future on a given date.

var continuousFutureSymbol = QuantConnect.Symbol.Create(Futures.Indices.SP500EMini, SecurityType.Future, Market.CME);
var contractSymbols = FutureChainProvider.GetFutureContractList(continuousFutureSymbol, Time);
_contractSymbol = contractSymbols.OrderByDescending(symbol => symbol.ID.Date).Last();

continuous_future_symbol = Symbol.Create(Futures.Indices.SP500EMini, SecurityType.Future, Market.CME)
contract_symbols = self.FutureChainProvider.GetFutureContractList(continuous_future_symbol, self.Time)
self.contract_symbol = sorted(contract_symbols, key=lambda symbol: symbol.ID.Date)[0]

Subscribe to Contracts

To create a Futures contract subscription, pass the contract Symbol to the AddFutureContract method. Save a reference to the contract Symbol so you can easily access the contract in the FuturesChain that LEAN passes to the OnData method.

AddFutureContract(_contractSymbol);

self.AddFutureContract(self.contract_symbol)

The AddFutureContract method creates a subscription for a single Future contract and adds it to your user-defined universe. To create a dynamic universe of Futures contracts, add a Futures universe or a Futures Universe Selection model .